@kernhq/module-inventory 0.1.2 → 0.3.0

package/dist/server/_impl.d.ts

@@ -1,427 +0,0 @@
-import { defineModule, defineServerModule, type Kernel, packageVersion, type RequestContext } from '@kernhq/kernel';
-/**
- * The router, kept apart from `index.ts` so `module.test.ts` can walk it without booting a kernel.
- *
- * Two middlewares on every procedure, and the test fails if either is missing:
- * `workspaceScoped` (a real membership, and the module switched on for that workspace) and
- * `requires` (the permission this particular call needs).
- */
-export { defineModule, defineServerModule, packageVersion };
-export declare function implement_(kernel: Kernel): {
-    assets: {
-        list: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
-            workspaceId: string;
-            kernel: Kernel;
-            principal: {
-                kind: "service" | "user" | "api_key" | "anonymous";
-                userId: (string & import("zod").$brand<"UserId">) | null;
-                email: string | null;
-                name: string | null;
-                locale: "en" | "fa" | "ar" | "de";
-                instanceAdmin: boolean;
-                service: string | null;
-                memberships: {
-                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
-                    role: "owner" | "admin" | "member" | "guest";
-                    roleIds: string[];
-                    groupIds: string[];
-                    status: "active" | "invited" | "suspended";
-                }[];
-                permissionVersion: number;
-            };
-            requestId: string;
-            ip: string;
-            headers: Record<string, string | string[] | undefined>;
-        }>, never> & Record<never, never>, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            q: import("zod").ZodOptional<import("zod").ZodString>;
-            categoryId: import("zod").ZodOptional<import("zod").ZodUUID>;
-            status: import("zod").ZodOptional<import("zod").ZodEnum<{
-                in_stock: "in_stock";
-                assigned: "assigned";
-                under_repair: "under_repair";
-                retired: "retired";
-            }>>;
-            sort: import("zod").ZodDefault<import("zod").ZodEnum<{
-                code: "code";
-                name: "name";
-                recent: "recent";
-            }>>;
-            cursor: import("zod").ZodOptional<import("zod").ZodString>;
-            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            items: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodUUID;
-                workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-                code: import("zod").ZodString;
-                name: import("zod").ZodString;
-                description: import("zod").ZodString;
-                categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
-                status: import("zod").ZodEnum<{
-                    in_stock: "in_stock";
-                    assigned: "assigned";
-                    under_repair: "under_repair";
-                    retired: "retired";
-                }>;
-                custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
-                custodySince: import("zod").ZodNullable<import("zod").ZodString>;
-                serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
-                location: import("zod").ZodNullable<import("zod").ZodString>;
-                purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
-                purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
-                priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
-                currency: import("zod").ZodNullable<import("zod").ZodString>;
-                warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
-                photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
-                createdAt: import("zod").ZodString;
-                updatedAt: import("zod").ZodString;
-                archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
-            }, import("zod/v4/core").$strip>>;
-            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
-            total: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
-            BAD_REQUEST: {
-                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
-            };
-            UNAUTHORIZED: {};
-            FORBIDDEN: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    permission: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            NOT_FOUND: {};
-            CONFLICT: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    reason: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            RATE_LIMITED: {};
-            MODULE_DISABLED: {
-                data: import("zod").ZodObject<{
-                    module: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>;
-            };
-        }>>, Record<never, never>>;
-        get: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
-            workspaceId: string;
-            kernel: Kernel;
-            principal: {
-                kind: "service" | "user" | "api_key" | "anonymous";
-                userId: (string & import("zod").$brand<"UserId">) | null;
-                email: string | null;
-                name: string | null;
-                locale: "en" | "fa" | "ar" | "de";
-                instanceAdmin: boolean;
-                service: string | null;
-                memberships: {
-                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
-                    role: "owner" | "admin" | "member" | "guest";
-                    roleIds: string[];
-                    groupIds: string[];
-                    status: "active" | "invited" | "suspended";
-                }[];
-                permissionVersion: number;
-            };
-            requestId: string;
-            ip: string;
-            headers: Record<string, string | string[] | undefined>;
-        }>, never> & Record<never, never>, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            assetId: import("zod").ZodUUID;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            id: import("zod").ZodUUID;
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            code: import("zod").ZodString;
-            name: import("zod").ZodString;
-            description: import("zod").ZodString;
-            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            status: import("zod").ZodEnum<{
-                in_stock: "in_stock";
-                assigned: "assigned";
-                under_repair: "under_repair";
-                retired: "retired";
-            }>;
-            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
-            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
-            location: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
-            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
-            currency: import("zod").ZodNullable<import("zod").ZodString>;
-            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
-            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            createdAt: import("zod").ZodString;
-            updatedAt: import("zod").ZodString;
-            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
-            BAD_REQUEST: {
-                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
-            };
-            UNAUTHORIZED: {};
-            FORBIDDEN: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    permission: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            NOT_FOUND: {};
-            CONFLICT: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    reason: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            RATE_LIMITED: {};
-            MODULE_DISABLED: {
-                data: import("zod").ZodObject<{
-                    module: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>;
-            };
-        }>>, Record<never, never>>;
-        create: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
-            workspaceId: string;
-            kernel: Kernel;
-            principal: {
-                kind: "service" | "user" | "api_key" | "anonymous";
-                userId: (string & import("zod").$brand<"UserId">) | null;
-                email: string | null;
-                name: string | null;
-                locale: "en" | "fa" | "ar" | "de";
-                instanceAdmin: boolean;
-                service: string | null;
-                memberships: {
-                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
-                    role: "owner" | "admin" | "member" | "guest";
-                    roleIds: string[];
-                    groupIds: string[];
-                    status: "active" | "invited" | "suspended";
-                }[];
-                permissionVersion: number;
-            };
-            requestId: string;
-            ip: string;
-            headers: Record<string, string | string[] | undefined>;
-        }>, never> & Record<never, never>, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            name: import("zod").ZodString;
-            description: import("zod").ZodDefault<import("zod").ZodString>;
-            categoryId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUUID>>;
-            serialNumber: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            location: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            purchasedFrom: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-            purchasedOn: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>;
-            warrantyUntil: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>;
-            priceMinor: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
-            currency: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            id: import("zod").ZodUUID;
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            code: import("zod").ZodString;
-            name: import("zod").ZodString;
-            description: import("zod").ZodString;
-            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            status: import("zod").ZodEnum<{
-                in_stock: "in_stock";
-                assigned: "assigned";
-                under_repair: "under_repair";
-                retired: "retired";
-            }>;
-            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
-            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
-            location: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
-            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
-            currency: import("zod").ZodNullable<import("zod").ZodString>;
-            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
-            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            createdAt: import("zod").ZodString;
-            updatedAt: import("zod").ZodString;
-            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
-            BAD_REQUEST: {
-                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
-            };
-            UNAUTHORIZED: {};
-            FORBIDDEN: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    permission: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            NOT_FOUND: {};
-            CONFLICT: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    reason: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            RATE_LIMITED: {};
-            MODULE_DISABLED: {
-                data: import("zod").ZodObject<{
-                    module: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>;
-            };
-        }>>, Record<never, never>>;
-        update: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
-            workspaceId: string;
-            kernel: Kernel;
-            principal: {
-                kind: "service" | "user" | "api_key" | "anonymous";
-                userId: (string & import("zod").$brand<"UserId">) | null;
-                email: string | null;
-                name: string | null;
-                locale: "en" | "fa" | "ar" | "de";
-                instanceAdmin: boolean;
-                service: string | null;
-                memberships: {
-                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
-                    role: "owner" | "admin" | "member" | "guest";
-                    roleIds: string[];
-                    groupIds: string[];
-                    status: "active" | "invited" | "suspended";
-                }[];
-                permissionVersion: number;
-            };
-            requestId: string;
-            ip: string;
-            headers: Record<string, string | string[] | undefined>;
-        }>, never> & Record<never, never>, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            name: import("zod").ZodOptional<import("zod").ZodString>;
-            description: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodString>>;
-            categoryId: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUUID>>>;
-            serialNumber: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
-            location: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
-            purchasedFrom: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
-            purchasedOn: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>>;
-            warrantyUntil: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>>;
-            priceMinor: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>>;
-            currency: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
-            assetId: import("zod").ZodUUID;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            id: import("zod").ZodUUID;
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            code: import("zod").ZodString;
-            name: import("zod").ZodString;
-            description: import("zod").ZodString;
-            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            status: import("zod").ZodEnum<{
-                in_stock: "in_stock";
-                assigned: "assigned";
-                under_repair: "under_repair";
-                retired: "retired";
-            }>;
-            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
-            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
-            location: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
-            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
-            currency: import("zod").ZodNullable<import("zod").ZodString>;
-            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
-            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            createdAt: import("zod").ZodString;
-            updatedAt: import("zod").ZodString;
-            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
-            BAD_REQUEST: {
-                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
-            };
-            UNAUTHORIZED: {};
-            FORBIDDEN: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    permission: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            NOT_FOUND: {};
-            CONFLICT: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    reason: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            RATE_LIMITED: {};
-            MODULE_DISABLED: {
-                data: import("zod").ZodObject<{
-                    module: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>;
-            };
-        }>>, Record<never, never>>;
-        archive: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
-            workspaceId: string;
-            kernel: Kernel;
-            principal: {
-                kind: "service" | "user" | "api_key" | "anonymous";
-                userId: (string & import("zod").$brand<"UserId">) | null;
-                email: string | null;
-                name: string | null;
-                locale: "en" | "fa" | "ar" | "de";
-                instanceAdmin: boolean;
-                service: string | null;
-                memberships: {
-                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
-                    role: "owner" | "admin" | "member" | "guest";
-                    roleIds: string[];
-                    groupIds: string[];
-                    status: "active" | "invited" | "suspended";
-                }[];
-                permissionVersion: number;
-            };
-            requestId: string;
-            ip: string;
-            headers: Record<string, string | string[] | undefined>;
-        }>, never> & Record<never, never>, import("zod").ZodObject<{
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            assetId: import("zod").ZodUUID;
-            archived: import("zod").ZodDefault<import("zod").ZodBoolean>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            id: import("zod").ZodUUID;
-            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
-            code: import("zod").ZodString;
-            name: import("zod").ZodString;
-            description: import("zod").ZodString;
-            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            status: import("zod").ZodEnum<{
-                in_stock: "in_stock";
-                assigned: "assigned";
-                under_repair: "under_repair";
-                retired: "retired";
-            }>;
-            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
-            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
-            location: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
-            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
-            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
-            currency: import("zod").ZodNullable<import("zod").ZodString>;
-            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
-            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
-            createdAt: import("zod").ZodString;
-            updatedAt: import("zod").ZodString;
-            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
-            BAD_REQUEST: {
-                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
-            };
-            UNAUTHORIZED: {};
-            FORBIDDEN: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    permission: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            NOT_FOUND: {};
-            CONFLICT: {
-                data: import("zod").ZodOptional<import("zod").ZodObject<{
-                    reason: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>>;
-            };
-            RATE_LIMITED: {};
-            MODULE_DISABLED: {
-                data: import("zod").ZodObject<{
-                    module: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>;
-            };
-        }>>, Record<never, never>>;
-    };
-};
-//# sourceMappingURL=_impl.d.ts.map

package/dist/server/_impl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_impl.d.ts","sourceRoot":"","sources":["../../src/server/_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,KAAK,MAAM,EACX,cAAc,EACd,KAAK,cAAc,EAKpB,MAAM,gBAAgB,CAAA;AAMvB;;;;;;GAMG;AACH,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAA;AAkD3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwMxC"}

package/dist/server/_impl.js

@@ -1,204 +0,0 @@
-import { defineModule, defineServerModule, KernError, packageVersion, requires, uuidv7, workspaceScoped, } from '@kernhq/kernel';
-import { implement } from '@orpc/server';
-import { and, desc, eq, ilike, or, sql } from 'drizzle-orm';
-import { inventoryContract, inventoryEvents, MODULE_ID } from '../contract.js';
-import { assetHistory, assets, counters } from './schema.js';
-/**
- * The router, kept apart from `index.ts` so `module.test.ts` can walk it without booting a kernel.
- *
- * Two middlewares on every procedure, and the test fails if either is missing:
- * `workspaceScoped` (a real membership, and the module switched on for that workspace) and
- * `requires` (the permission this particular call needs).
- */
-export { defineModule, defineServerModule, packageVersion };
-const os = implement(inventoryContract).$context();
-/** The wire shape: drizzle gives Date objects for timestamps, the contract promises ISO strings. */
-function toAsset(row) {
-    return {
-        id: row.id,
-        workspaceId: row.workspaceId,
-        code: row.code,
-        name: row.name,
-        description: row.description,
-        categoryId: row.categoryId,
-        status: row.status,
-        custodianUserId: row.custodianUserId,
-        custodySince: row.custodySince?.toISOString() ?? null,
-        serialNumber: row.serialNumber,
-        location: row.location,
-        purchasedOn: row.purchasedOn ?? null,
-        purchasedFrom: row.purchasedFrom,
-        priceMinor: row.priceMinor,
-        currency: row.currency,
-        warrantyUntil: row.warrantyUntil ?? null,
-        photoFileId: row.photoFileId,
-        createdAt: row.createdAt.toISOString(),
-        updatedAt: row.updatedAt.toISOString(),
-        archivedAt: row.archivedAt?.toISOString() ?? null,
-    };
-}
-/**
- * The next asset tag for a workspace. One narrow row per workspace and key, incremented under the
- * insert's conflict lock — two concurrent creates each read the value their own update returned, so
- * codes stay unique without a retry loop. `INV-0042`, because people say asset tags out loud.
- */
-async function nextCode(tx, workspaceId) {
-    const [row] = await tx
-        .insert(counters)
-        .values({ workspaceId, key: 'asset_code', value: 1 })
-        .onConflictDoUpdate({
-        target: [counters.workspaceId, counters.key],
-        set: { value: sql `${counters.value} + 1` },
-    })
-        .returning();
-    return `INV-${String(row.value).padStart(4, '0')}`;
-}
-export function implement_(kernel) {
-    const scoped = os.use(workspaceScoped(MODULE_ID));
-    const changed = (workspaceId, id, op) => kernel.realtime.change(workspaceId, { module: MODULE_ID, entity: 'asset', id, op });
-    async function record(tx, input, assetId, actorId, action, changes = [], data) {
-        await tx.insert(assetHistory).values({
-            id: uuidv7(),
-            workspaceId: input.workspaceId,
-            assetId,
-            actorId: actorId ?? null,
-            action,
-            changes,
-            data: data ?? null,
-        });
-    }
-    return os.router({
-        assets: {
-            list: scoped.assets.list.use(requires('inventory.asset.view')).handler(({ input }) => kernel.database.withWorkspace(input.workspaceId, async (tx) => {
-                const filters = [eq(assets.workspaceId, input.workspaceId)];
-                if (input.q) {
-                    // A code is something somebody reads off a sticker; matching name, code and serial
-                    // loosely matters more than word-splitting here. Full-text arrives with the core indexer.
-                    filters.push(or(ilike(assets.name, `%${input.q}%`), ilike(assets.code, `%${input.q}%`), ilike(sql `coalesce(${assets.serialNumber}, '')`, `%${input.q}%`)));
-                }
-                if (input.categoryId)
-                    filters.push(eq(assets.categoryId, input.categoryId));
-                if (input.status)
-                    filters.push(eq(assets.status, input.status));
-                const order = input.sort === 'name' ? assets.name : input.sort === 'code' ? assets.code : desc(assets.createdAt);
-                const rows = await tx
-                    .select()
-                    .from(assets)
-                    .where(and(...filters))
-                    .orderBy(order)
-                    .limit(input.limit);
-                return { items: rows.map(toAsset), nextCursor: null };
-            })),
-            get: scoped.assets.get.use(requires('inventory.asset.view')).handler(({ input }) => kernel.database.withWorkspace(input.workspaceId, async (tx) => {
-                const [row] = await tx
-                    .select()
-                    .from(assets)
-                    .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)));
-                if (!row)
-                    throw KernError.notFound('Asset');
-                return toAsset(row);
-            })),
-            create: scoped.assets.create
-                .use(requires('inventory.asset.manage'))
-                .handler(async ({ input, context }) => {
-                const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
-                    const [r] = await tx
-                        .insert(assets)
-                        .values({
-                        id: uuidv7(),
-                        workspaceId: input.workspaceId,
-                        code: await nextCode(tx, input.workspaceId),
-                        name: input.name,
-                        description: input.description,
-                        categoryId: input.categoryId ?? null,
-                        serialNumber: input.serialNumber ?? null,
-                        location: input.location ?? null,
-                        purchasedFrom: input.purchasedFrom ?? null,
-                        purchasedOn: input.purchasedOn ?? null,
-                        warrantyUntil: input.warrantyUntil ?? null,
-                        priceMinor: input.priceMinor ?? null,
-                        currency: input.currency ?? null,
-                    })
-                        .returning();
-                    await record(tx, input, r.id, context.principal.userId, 'created');
-                    return r;
-                });
-                // Both, every time. The event is for anything that reacts later; the realtime change is
-                // what redraws a screen somebody is looking at now. A mutation that does neither leaves
-                // the rest of the product believing the old answer.
-                await kernel.emit(inventoryEvents.assetCreated, { assetId: row.id, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
-                await changed(input.workspaceId, row.id, 'created');
-                return toAsset(row);
-            }),
-            update: scoped.assets.update
-                .use(requires('inventory.asset.manage'))
-                .handler(async ({ input, context }) => {
-                const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
-                    const [prev] = await tx
-                        .select()
-                        .from(assets)
-                        .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)))
-                        .for('update');
-                    if (!prev)
-                        throw KernError.notFound('Asset');
-                    const patch = {
-                        name: input.name ?? prev.name,
-                        description: input.description ?? prev.description,
-                        categoryId: input.categoryId !== undefined ? (input.categoryId ?? null) : prev.categoryId,
-                        serialNumber: input.serialNumber !== undefined ? (input.serialNumber ?? null) : prev.serialNumber,
-                        location: input.location !== undefined ? (input.location ?? null) : prev.location,
-                        purchasedFrom: input.purchasedFrom !== undefined ? (input.purchasedFrom ?? null) : prev.purchasedFrom,
-                        purchasedOn: input.purchasedOn !== undefined ? (input.purchasedOn ?? null) : prev.purchasedOn,
-                        warrantyUntil: input.warrantyUntil !== undefined ? (input.warrantyUntil ?? null) : prev.warrantyUntil,
-                        priceMinor: input.priceMinor !== undefined ? (input.priceMinor ?? null) : prev.priceMinor,
-                        currency: input.currency !== undefined ? (input.currency ?? null) : prev.currency,
-                        updatedAt: new Date(),
-                    };
-                    const [r] = await tx.update(assets).set(patch).where(eq(assets.id, input.assetId)).returning();
-                    // Field-level diffs are the timeline — write only what actually moved.
-                    const fields = [
-                        'name',
-                        'description',
-                        'categoryId',
-                        'serialNumber',
-                        'location',
-                        'purchasedFrom',
-                        'purchasedOn',
-                        'warrantyUntil',
-                        'priceMinor',
-                        'currency',
-                    ];
-                    const iso = (v) => (v instanceof Date ? v.toISOString() : v) ?? null;
-                    const changes = fields
-                        .filter((f) => iso(patch[f]) !== iso(prev[f]))
-                        .map((f) => ({ field: f, from: iso(prev[f]), to: iso(patch[f]) }));
-                    if (changes.length > 0)
-                        await record(tx, input, input.assetId, context.principal.userId, 'updated', changes);
-                    return r;
-                });
-                await kernel.emit(inventoryEvents.assetUpdated, { assetId: row.id, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
-                await changed(input.workspaceId, row.id, 'updated');
-                return toAsset(row);
-            }),
-            archive: scoped.assets.archive
-                .use(requires('inventory.asset.manage'))
-                .handler(async ({ input, context }) => {
-                const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
-                    const [r] = await tx
-                        .update(assets)
-                        .set({ archivedAt: input.archived ? new Date() : null, updatedAt: new Date() })
-                        .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)))
-                        .returning();
-                    if (!r)
-                        throw KernError.notFound('Asset');
-                    await record(tx, input, input.assetId, context.principal.userId, input.archived ? 'retired' : 'restored');
-                    return r;
-                });
-                await kernel.emit(inventoryEvents.assetArchived, { assetId: row.id, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
-                await changed(input.workspaceId, row.id, 'updated');
-                return toAsset(row);
-            }),
-        },
-    });
-}
-//# sourceMappingURL=_impl.js.map