@cosmicdrift/kumiko-bundled-features 0.383.0 → 0.384.0

package/dist/personal-access-tokens/schema/api-token.d.ts

@@ -1,140 +1,20 @@
 export declare const apiTokenEntity: import("@cosmicdrift/kumiko-types/fields").EntityDefinition<{
-    readonly userId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly userId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly tenantId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly tenantId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly name: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly name: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly tokenHash: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly tokenHash: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly prefix: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly prefix: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly scopes: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly scopes: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
     readonly createdAt: {

package/dist/secrets/i18n.d.ts

@@ -1,14 +1,11 @@
 export declare const SECRETS_I18N: {
     readonly "secrets.errors.unknownKey": {
         readonly en: "Unknown secret key.";
-        readonly de: "Unbekannter Geheimnis-Schlüssel.";
     };
     readonly "secrets.errors.writeDenied": {
         readonly en: "You are not allowed to change this secret.";
-        readonly de: "Dieses Geheimnis darf nicht geändert werden.";
     };
     readonly "secrets.errors.invalidValue": {
         readonly en: "This value is not valid for this secret.";
-        readonly de: "Dieser Wert ist für dieses Geheimnis nicht gültig.";
     };
 };

package/dist/secrets/i18n.js

@@ -2,14 +2,11 @@ import { SECRETS_ERROR_KEYS } from "./web/constants.js";
 export const SECRETS_I18N = {
     [SECRETS_ERROR_KEYS.unknownKey]: {
         en: "Unknown secret key.",
-        de: "Unbekannter Geheimnis-Schlüssel.",
     },
     [SECRETS_ERROR_KEYS.writeDenied]: {
         en: "You are not allowed to change this secret.",
-        de: "Dieses Geheimnis darf nicht geändert werden.",
     },
     [SECRETS_ERROR_KEYS.invalidValue]: {
         en: "This value is not valid for this secret.",
-        de: "Dieser Wert ist für dieses Geheimnis nicht gültig.",
     },
 };

package/dist/secrets/table.d.ts

@@ -4,27 +4,7 @@ export type StoredMetadata = {
     readonly hint?: string;
 };
 export declare const tenantSecretEntity: import("@cosmicdrift/kumiko-types/fields").EntityDefinition<{
-    readonly key: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly key: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
     readonly kekVersion: {

package/dist/sessions/constants.d.ts

@@ -1,4 +1,5 @@
-export declare const SESSIONS_FEATURE: "sessions";
+import { SESSIONS_FEATURE } from "./web/constants.ts";
+export { SESSIONS_FEATURE };
 export declare const USER_SESSION_ENTITY_NAME: "user-session";
 export declare const SessionHandlers: {
     readonly revoke: "sessions:write:user-session:revoke";

package/dist/sessions/constants.js

@@ -1,4 +1,5 @@
-export const SESSIONS_FEATURE = "sessions";
+import { SESSIONS_FEATURE } from "./web/constants.js";
+export { SESSIONS_FEATURE };
 export const USER_SESSION_ENTITY_NAME = "user-session";
 // Qualified write handler names — entity prefix is "userSession", snake_case
 // "user_session" on the wire.

package/dist/sessions/handlers/detail.query.d.ts

@@ -9,4 +9,9 @@ export declare const createDetailQuery: (adminRoles?: readonly string[]) => impo
     revokedAt: unknown;
     ip: string | null;
     userAgent: string | null;
+    device: {
+        browser: "Chrome" | "Edge" | "Firefox" | "Opera" | "Safari" | "Samsung Internet" | null;
+        browserMajor: number | null;
+        os: "Android" | "ChromeOS" | "Linux" | "Windows" | "iOS" | "macOS" | null;
+    } | null;
 } | null, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/sessions/handlers/detail.query.js

@@ -3,6 +3,7 @@ import { access, defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine
 import * as z from "zod";
 import { decryptStoredPii } from "../../shared/index.js";
 import { userSessionTable } from "../schema/user-session.js";
+import { parsedDeviceSchema, parseUserAgent } from "../web/user-agent.js";
 // Admin single-session inspector — mirrors list.query's decrypt handling for
 // the one-row case. ctx.db (TenantDb) applies tenant-scoping automatically.
 const sessionRowSchema = z.object({
@@ -13,6 +14,7 @@ const sessionRowSchema = z.object({
     revokedAt: z.unknown(),
     ip: z.string().nullable(),
     userAgent: z.string().nullable(),
+    device: parsedDeviceSchema,
 });
 export const createDetailQuery = (adminRoles = access.admin) => defineQueryHandler({
     name: "user-session:detail",
@@ -26,6 +28,9 @@ export const createDetailQuery = (adminRoles = access.admin) => defineQueryHandl
         const row = await fetchOne(ctx.db, userSessionTable, { id: query.payload.id });
         if (!row)
             return null;
+        const userAgent = row.userAgent
+            ? await decryptStoredPii(row.userAgent, "userAgent", "sessions:detail")
+            : row.userAgent;
         return {
             id: row.id,
             userId: row.userId,
@@ -33,9 +38,8 @@ export const createDetailQuery = (adminRoles = access.admin) => defineQueryHandl
             expiresAt: row.expiresAt,
             revokedAt: row.revokedAt,
             ip: row.ip ? await decryptStoredPii(row.ip, "ip", "sessions:detail") : row.ip,
-            userAgent: row.userAgent
-                ? await decryptStoredPii(row.userAgent, "userAgent", "sessions:detail")
-                : row.userAgent,
+            userAgent,
+            device: parseUserAgent(userAgent),
         };
     },
 });

package/dist/sessions/handlers/list.query.d.ts

@@ -14,4 +14,9 @@ export declare const createListQuery: (adminRoles?: readonly string[]) => import
     revokedAt: unknown;
     ip: string | null;
     userAgent: string | null;
+    device: {
+        browser: "Chrome" | "Edge" | "Firefox" | "Opera" | "Safari" | "Samsung Internet" | null;
+        browserMajor: number | null;
+        os: "Android" | "ChromeOS" | "Linux" | "Windows" | "iOS" | "macOS" | null;
+    } | null;
 }, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/sessions/handlers/list.query.js

@@ -4,6 +4,7 @@ import { isOneOf } from "@cosmicdrift/kumiko-types/type-guards";
 import * as z from "zod";
 import { decryptStoredPii } from "../../shared/index.js";
 import { userSessionTable } from "../schema/user-session.js";
+import { parsedDeviceSchema, parseUserAgent } from "../web/user-agent.js";
 // `sort` arrives raw from the client's query string. selectMany's orderBy
 // has no column-existence check — an unrecognised field just gets
 // snake_cased and quoted as-is (db/query.ts columnOf) — so this
@@ -36,6 +37,7 @@ export const createListQuery = (adminRoles = access.admin) => definePagedQueryHa
             revokedAt: z.unknown(),
             ip: z.string().nullable(),
             userAgent: z.string().nullable(),
+            device: parsedDeviceSchema,
         })),
         nextCursor: z.string().nullable(),
     }),
@@ -56,17 +58,21 @@ export const createListQuery = (adminRoles = access.admin) => definePagedQueryHa
                 ],
             ...(query.payload.limit !== undefined && { limit: query.payload.limit }),
         });
-        const decryptedRows = await Promise.all(rows.map(async (r) => ({
-            id: r.id,
-            userId: r.userId,
-            createdAt: r.createdAt,
-            expiresAt: r.expiresAt,
-            revokedAt: r.revokedAt,
-            ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:list") : r.ip,
-            userAgent: r.userAgent
+        const decryptedRows = await Promise.all(rows.map(async (r) => {
+            const userAgent = r.userAgent
                 ? await decryptStoredPii(r.userAgent, "userAgent", "sessions:list")
-                : r.userAgent,
-        })));
+                : r.userAgent;
+            return {
+                id: r.id,
+                userId: r.userId,
+                createdAt: r.createdAt,
+                expiresAt: r.expiresAt,
+                revokedAt: r.revokedAt,
+                ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:list") : r.ip,
+                userAgent,
+                device: parseUserAgent(userAgent),
+            };
+        }));
         return { rows: decryptedRows, nextCursor: null };
     },
 });

package/dist/sessions/handlers/mine.query.d.ts

@@ -5,5 +5,10 @@ export declare const mineQuery: import("@cosmicdrift/kumiko-framework/engine").P
     expiresAt: unknown;
     ip: string | null;
     userAgent: string | null;
+    device: {
+        browser: "Chrome" | "Edge" | "Firefox" | "Opera" | "Safari" | "Samsung Internet" | null;
+        browserMajor: number | null;
+        os: "Android" | "ChromeOS" | "Linux" | "Windows" | "iOS" | "macOS" | null;
+    } | null;
     current: boolean;
 }, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/sessions/handlers/mine.query.js

@@ -3,6 +3,7 @@ import { definePagedQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { decryptStoredPii } from "../../shared/index.js";
 import { userSessionTable } from "../schema/user-session.js";
+import { parsedDeviceSchema, parseUserAgent } from "../web/user-agent.js";
 // "My live sessions" — the backing data for a devices/sessions UI. Returns
 // ONLY the current user's own, currently-live sessions, ordered by most-
 // recently-used first. Revoked rows excluded (revokedAt IS NULL). Paged
@@ -25,6 +26,7 @@ export const mineQuery = definePagedQueryHandler({
             expiresAt: z.unknown(),
             ip: z.string().nullable(),
             userAgent: z.string().nullable(),
+            device: parsedDeviceSchema,
             current: z.boolean(),
         })),
         nextCursor: z.string().nullable(),
@@ -34,16 +36,20 @@ export const mineQuery = definePagedQueryHandler({
             orderBy: { col: "createdAt", direction: "desc" },
         });
         const currentSid = query.user.sid;
-        const decryptedRows = await Promise.all(rows.map(async (r) => ({
-            id: r.id,
-            createdAt: r.createdAt,
-            expiresAt: r.expiresAt,
-            ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:mine") : r.ip,
-            userAgent: r.userAgent
+        const decryptedRows = await Promise.all(rows.map(async (r) => {
+            const userAgent = r.userAgent
                 ? await decryptStoredPii(r.userAgent, "userAgent", "sessions:mine")
-                : r.userAgent,
-            current: currentSid === r.id,
-        })));
+                : r.userAgent;
+            return {
+                id: r.id,
+                createdAt: r.createdAt,
+                expiresAt: r.expiresAt,
+                ip: r.ip ? await decryptStoredPii(r.ip, "ip", "sessions:mine") : r.ip,
+                userAgent,
+                device: parseUserAgent(userAgent),
+                current: currentSid === r.id,
+            };
+        }));
         return { rows: decryptedRows, nextCursor: null };
     },
 });

package/dist/sessions/schema/user-session.d.ts

@@ -1,48 +1,8 @@
 export declare const userSessionEntity: import("@cosmicdrift/kumiko-types/fields").EntityDefinition<{
-    readonly userId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly userId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
-    readonly tenantId: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly tenantId: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: true;
     };
     readonly createdAt: {
@@ -105,50 +65,10 @@ export declare const userSessionEntity: import("@cosmicdrift/kumiko-types/fields
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: false;
     };
-    readonly ip: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly ip: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: false;
     };
-    readonly userAgent: {
-        readonly type: "text";
-        readonly description?: string;
-        readonly maxLength?: number;
-        readonly minLength?: number;
-        readonly autoComplete?: string;
-        readonly required?: boolean;
-        readonly searchable?: boolean;
-        readonly sortable?: boolean;
-        readonly filterable?: boolean;
-        readonly encrypted?: boolean;
-        readonly sensitive?: boolean;
-        readonly writeOnly?: boolean;
-        readonly readAsInstruction?: boolean;
-        readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
-        readonly default?: string;
-        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
-        readonly multiline?: boolean | {
-            readonly rows?: number;
-        };
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    readonly userAgent: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
         required: false;
     };
 }, "tenant">;

package/dist/sessions/screens.js

@@ -1,5 +1,7 @@
 import { access, i18nKey, MAX_LIST_LIMIT, } from "@cosmicdrift/kumiko-framework/engine";
 import { SESSION_DETAIL_SCREEN_ID, SESSION_LIST_SCREEN_ID, SESSION_MINE_SCREEN_ID, SessionHandlers, SessionQueries, } from "./constants.js";
+import { SESSION_DEVICE_CELL_COMPONENT } from "./web/constants.js";
+const DEVICE_RENDERER = { react: { __component: SESSION_DEVICE_CELL_COMPONENT } };
 export const createSessionListScreen = (adminRoles = access.admin) => ({
     id: SESSION_LIST_SCREEN_ID,
     type: "projectionList",
@@ -20,6 +22,11 @@ export const createSessionListScreen = (adminRoles = access.admin) => ({
             refEntity: "user:user",
             refLabelField: "displayName",
         },
+        {
+            field: "device",
+            label: i18nKey("sessions.list.col.device"),
+            renderer: DEVICE_RENDERER,
+        },
         {
             field: "createdAt",
             label: i18nKey("sessions.list.col.createdAt"),
@@ -28,6 +35,7 @@ export const createSessionListScreen = (adminRoles = access.admin) => ({
         {
             field: "expiresAt",
             label: i18nKey("sessions.list.col.expiresAt"),
+            hideOnNarrow: true,
             renderer: { format: "timestamp" },
         },
         {
@@ -67,6 +75,7 @@ export const createSessionDetailScreen = (adminRoles = access.admin) => ({
                     { field: "createdAt", renderer: { format: "timestamp" } },
                     { field: "expiresAt", renderer: { format: "timestamp" } },
                     { field: "revokedAt", renderer: { format: "timestamp" } },
+                    { field: "device", renderer: DEVICE_RENDERER },
                     "ip",
                     "userAgent",
                 ],
@@ -79,6 +88,7 @@ export const createSessionDetailScreen = (adminRoles = access.admin) => ({
         createdAt: i18nKey("sessions.detail.field.createdAt"),
         expiresAt: i18nKey("sessions.detail.field.expiresAt"),
         revokedAt: i18nKey("sessions.detail.field.revokedAt"),
+        device: i18nKey("sessions.list.col.device"),
         ip: i18nKey("sessions.detail.field.ip"),
         userAgent: i18nKey("sessions.detail.field.userAgent"),
     },
@@ -90,6 +100,17 @@ export const sessionMineScreen = {
     type: "projectionList",
     query: SessionQueries.mine,
     columns: [
+        { field: "device", label: i18nKey("sessions.mine.col.userAgent"), renderer: DEVICE_RENDERER },
+        { field: "ip", label: i18nKey("sessions.mine.col.ip") },
+        {
+            field: "current",
+            label: i18nKey("sessions.mine.col.current"),
+            renderer: {
+                format: "boolean",
+                trueLabel: i18nKey("sessions.mine.current.yes"),
+                falseLabel: i18nKey("sessions.mine.current.no"),
+            },
+        },
         {
             field: "createdAt",
             label: i18nKey("sessions.list.col.createdAt"),
@@ -98,15 +119,8 @@ export const sessionMineScreen = {
         {
             field: "expiresAt",
             label: i18nKey("sessions.list.col.expiresAt"),
-            renderer: { format: "timestamp" },
-        },
-        { field: "ip", label: i18nKey("sessions.mine.col.ip") },
-        { field: "userAgent", label: i18nKey("sessions.mine.col.userAgent") },
-        {
-            field: "current",
-            label: i18nKey("sessions.mine.col.current"),
             hideOnNarrow: true,
-            renderer: { format: "boolean" },
+            renderer: { format: "timestamp" },
         },
     ],
     rowActions: [

package/dist/sessions/web/client-plugin.d.ts

@@ -0,0 +1,6 @@
+import { type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer/web";
+export type SessionsClientOptions = {
+    readonly translations?: TranslationsByLocale;
+};
+export declare function sessionsClient(options?: SessionsClientOptions): ClientFeatureDefinition;

package/dist/sessions/web/client-plugin.js

@@ -0,0 +1,11 @@
+import { mergeTranslations } from "@cosmicdrift/kumiko-renderer";
+import { SESSION_DEVICE_CELL_COMPONENT, SESSIONS_FEATURE } from "./constants.js";
+import { defaultTranslations } from "./default-translations.js";
+import { SessionDeviceCell } from "./session-device-cell.js";
+export function sessionsClient(options) {
+    return {
+        name: SESSIONS_FEATURE,
+        translations: mergeTranslations(defaultTranslations, options?.translations ?? {}),
+        columnRenderers: { [SESSION_DEVICE_CELL_COMPONENT]: SessionDeviceCell },
+    };
+}

package/dist/sessions/web/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const SESSIONS_FEATURE: "sessions";
+/** Column-renderer name shared by screens.ts and `sessionsClient()`. */
+export declare const SESSION_DEVICE_CELL_COMPONENT: "session-device-cell";

package/dist/sessions/web/constants.js

@@ -0,0 +1,3 @@
+export const SESSIONS_FEATURE = "sessions";
+/** Column-renderer name shared by screens.ts and `sessionsClient()`. */
+export const SESSION_DEVICE_CELL_COMPONENT = "session-device-cell";

package/dist/sessions/web/default-translations.d.ts

@@ -0,0 +1,2 @@
+import { type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
+export declare const defaultTranslations: TranslationsByLocale;

package/dist/sessions/web/default-translations.js

@@ -0,0 +1,3 @@
+import { translationsByLocaleFromKeys, } from "@cosmicdrift/kumiko-renderer";
+import { SESSIONS_I18N } from "./i18n.js";
+export const defaultTranslations = translationsByLocaleFromKeys(SESSIONS_I18N);

package/dist/sessions/web/i18n.js

@@ -19,7 +19,11 @@ export const SESSIONS_I18N = {
     "screen:my-sessions.title": { en: "Your sessions" },
     "sessions.mine.col.ip": { en: "IP address" },
     "sessions.mine.col.userAgent": { en: "Device" },
-    "sessions.mine.col.current": { en: "This device" },
+    "sessions.mine.col.current": { en: "Session" },
+    "sessions.mine.current.yes": { en: "This session" },
+    "sessions.mine.current.no": { en: "-" },
+    "sessions.list.col.device": { en: "Device" },
+    "sessions.device.unknown": { en: "Unknown device" },
     "sessions.mine.revoke": { en: "Sign out" },
     "sessions.mine.revoke.confirm": { en: "Sign this device out?" },
     "sessions.mine.revokeAllOthers": { en: "Sign out all other devices" },

package/dist/sessions/web/index.d.ts

@@ -0,0 +1 @@
+export { type SessionsClientOptions, sessionsClient } from "./client-plugin.tsx";

package/dist/sessions/web/index.js

@@ -0,0 +1 @@
+export { sessionsClient } from "./client-plugin.js";

package/dist/sessions/web/session-device-cell.d.ts

@@ -0,0 +1,3 @@
+import { type ColumnRendererProps } from "@cosmicdrift/kumiko-renderer";
+import type { ReactNode } from "react";
+export declare function SessionDeviceCell({ value }: ColumnRendererProps): ReactNode;

package/dist/sessions/web/session-device-cell.js

@@ -0,0 +1,16 @@
+// Column renderer for the parsed `device` of a session row, registered via `sessionsClient()`.
+import { useTranslation } from "@cosmicdrift/kumiko-renderer";
+import { parsedDeviceSchema } from "./user-agent.js";
+export function SessionDeviceCell({ value }) {
+    const t = useTranslation();
+    const parsed = parsedDeviceSchema.safeParse(value);
+    const device = parsed.success ? parsed.data : null;
+    if (device === null)
+        return t("sessions.device.unknown");
+    const browser = device.browser === null
+        ? null
+        : device.browserMajor === null
+            ? device.browser
+            : `${device.browser} ${device.browserMajor}`;
+    return [browser, device.os].filter((part) => part !== null).join(" · ");
+}