@orthacms/activity-server 0.0.0-reserve.0

package/dist/lib/activity/services/activity.service.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const utils_server_1 = require("@orthacms/utils-server");
+const schema_1 = require("../../schema");
+const activity_filter_1 = require("../activity-filter");
+const activity_constants_1 = require("../activity.constants");
+/** The sortable wire fields mapped to their `activity_events` columns. */
+const SORT_COLUMNS = {
+    at: schema_1.activityEvents.at,
+    kind: schema_1.activityEvents.kind
+};
+/**
+ * Owns the audit trail: appends events (`record`) and serves the paginated
+ * read API (`list`). Implements {@link ActivityRecorder} so foundational
+ * plugins can record via the `ACTIVITY_RECORDER` token without depending on
+ * this package. Uses the shared Drizzle client directly (no repository
+ * wrapper, by repo convention).
+ */
+let ActivityService = class ActivityService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Appends one audit row. Pass `executor = tx` to record **in-band** with a
+     * mutation, so the audit row commits iff the mutation does; defaults to the
+     * root client. `at` defaults to now; `actorId`/`actorEmail`/`meta` are
+     * nullable.
+     *
+     * @deprecated Wave 3 moved auditing onto the outbox `AuditEventSubscriber`,
+     * the single live writer. This method (and the `ACTIVITY_RECORDER` binding)
+     * is retained only for a stable public surface — no caller writes through it
+     * anymore. Emit a domain event and let the subscriber record it instead.
+     */
+    async record(input, executor = this.db) {
+        await executor.insert(schema_1.activityEvents).values({
+            kind: input.kind,
+            subjectType: input.subjectType,
+            subjectId: input.subjectId,
+            actorId: input.actorId ?? null,
+            actorEmail: input.actorEmail ?? null,
+            meta: input.meta ?? null,
+            at: input.at ?? new Date()
+        });
+    }
+    /**
+     * One page of events matching the filters, with a stable order: the
+     * whitelisted sort column (default `at desc`) plus an `id` tiebreaker so
+     * paging is deterministic across equal timestamps. `created_at` is never
+     * selected — the immutable write time stays off the wire.
+     */
+    async list(query) {
+        const page = query.page ?? 1;
+        const pageSize = query.pageSize ?? activity_constants_1.DEFAULT_PAGE_SIZE;
+        const where = await this.listWhere(query);
+        const sortColumn = SORT_COLUMNS[query.sort ?? 'at'];
+        const direction = query.order === 'asc' ? drizzle_orm_1.asc : drizzle_orm_1.desc;
+        // Count and page rows share the same WHERE but are otherwise
+        // independent; run them concurrently so a list request pays the max
+        // of the two query times, not their sum.
+        const [[{ total }], rows] = await Promise.all([
+            this.db
+                .select({ total: (0, drizzle_orm_1.count)() })
+                .from(schema_1.activityEvents)
+                .where(where),
+            this.db
+                .select({
+                id: schema_1.activityEvents.id,
+                kind: schema_1.activityEvents.kind,
+                subjectType: schema_1.activityEvents.subjectType,
+                subjectId: schema_1.activityEvents.subjectId,
+                actorId: schema_1.activityEvents.actorId,
+                actorEmail: schema_1.activityEvents.actorEmail,
+                meta: schema_1.activityEvents.meta,
+                at: schema_1.activityEvents.at
+            })
+                .from(schema_1.activityEvents)
+                .where(where)
+                .orderBy(direction(sortColumn), (0, drizzle_orm_1.desc)(schema_1.activityEvents.id))
+                .limit(pageSize)
+                .offset((page - 1) * pageSize)
+        ]);
+        return {
+            items: rows.map((row) => ({
+                ...row,
+                meta: row.meta ?? null
+            })),
+            total,
+            page,
+            pageSize
+        };
+    }
+    /**
+     * The full `where` for the list: the structured params (`listPredicate`)
+     * AND-ed with the optional query-builder `?filter=` tree. The filter is
+     * parsed and translated against {@link ACTIVITY_FILTER_SCHEMA}; a malformed
+     * filter throws a `FilterException` (HTTP 400). `and(undefined, …)`
+     * collapses cleanly, so an unfiltered list still scans everything.
+     */
+    async listWhere(query) {
+        const tree = (0, utils_server_1.parseFilterTree)(query.filter, activity_filter_1.ACTIVITY_FILTER_SCHEMA);
+        const filterSql = await (0, utils_server_1.applyFilterTree)(tree, activity_filter_1.ACTIVITY_FILTER_SCHEMA, schema_1.activityEvents, this.db);
+        return (0, drizzle_orm_1.and)(this.listPredicate(query), filterSql);
+    }
+    /**
+     * The structured-param `where` for the list: every supplied filter
+     * intersected (AND). `and(undefined, …)` collapses to no filter, so an
+     * unfiltered list scans everything.
+     */
+    listPredicate(query) {
+        return (0, drizzle_orm_1.and)(query.subjectType
+            ? (0, drizzle_orm_1.eq)(schema_1.activityEvents.subjectType, query.subjectType)
+            : undefined, query.subjectId
+            ? (0, drizzle_orm_1.eq)(schema_1.activityEvents.subjectId, query.subjectId)
+            : undefined, query.actorId
+            ? (0, drizzle_orm_1.eq)(schema_1.activityEvents.actorId, query.actorId)
+            : undefined, query.kind && query.kind.length > 0
+            ? (0, drizzle_orm_1.inArray)(schema_1.activityEvents.kind, query.kind)
+            : undefined, this.actorEmailPredicate(query.actorEmail), query.from
+            ? (0, drizzle_orm_1.gte)(schema_1.activityEvents.at, new Date(query.from))
+            : undefined, query.to ? (0, drizzle_orm_1.lte)(schema_1.activityEvents.at, new Date(query.to)) : undefined);
+    }
+    /**
+     * Case-insensitive substring match on the actor email snapshot, or
+     * `undefined` for no filter. LIKE metacharacters in the needle are escaped
+     * so a literal `%`/`_` search behaves literally.
+     */
+    actorEmailPredicate(search) {
+        const needle = search?.trim();
+        if (!needle) {
+            return undefined;
+        }
+        const escaped = needle.replace(/[\\%_]/g, '\\$&');
+        return (0, drizzle_orm_1.ilike)(schema_1.activityEvents.actorEmail, `%${escaped}%`);
+    }
+};
+exports.ActivityService = ActivityService;
+exports.ActivityService = ActivityService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ActivityService);

package/dist/lib/activity/types/activity-view.d.ts

@@ -0,0 +1,37 @@
+/**
+ * One audit event as returned by `GET /api/activity`. Mirrors the
+ * `activity_events` row minus `createdAt` (the immutable write time is an
+ * internal detail and never reaches the wire). `kind` is an open string and
+ * `meta` an open record — each emitting plugin owns its own kinds/shapes, and
+ * the admin restates the ones it renders.
+ */
+export interface ActivityEventView {
+    /** Event primary key. */
+    id: string;
+    /** The `domain.action` kind, owned by the emitting plugin. */
+    kind: string;
+    /** The kind of entity acted upon (e.g. `'user'`). */
+    subjectType: string;
+    /** The acted-upon entity's id (text). */
+    subjectId: string;
+    /** Who performed it, or `null` for a system-initiated event. */
+    actorId: string | null;
+    /** Frozen email snapshot of the actor, or `null`. */
+    actorEmail: string | null;
+    /** Open per-kind payload, or `null`. */
+    meta: Record<string, unknown> | null;
+    /** Logical event time. */
+    at: Date;
+}
+/** One page of audit events, as returned by `GET /api/activity`. */
+export interface ActivityListView {
+    /** The events on this page. */
+    items: ActivityEventView[];
+    /** Total events matching the filters, across all pages. */
+    total: number;
+    /** 1-based page number echoed back. */
+    page: number;
+    /** Page size echoed back. */
+    pageSize: number;
+}
+//# sourceMappingURL=activity-view.d.ts.map

package/dist/lib/activity/types/activity-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-view.d.ts","sourceRoot":"","sources":["../../../../src/lib/activity/types/activity-view.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAC9B,yBAAyB;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,qDAAqD;IACrD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrC,0BAA0B;IAC1B,EAAE,EAAE,IAAI,CAAC;CACZ;AAED,oEAAoE;AACpE,MAAM,WAAW,gBAAgB;IAC7B,+BAA+B;IAC/B,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,CAAC;CACpB"}

package/dist/lib/activity/types/activity-view.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/activity.module.d.ts

@@ -0,0 +1,20 @@
+import { DynamicModule } from '@nestjs/common';
+/**
+ * NestJS module for the activity plugin. Mounts the read API under
+ * `/api/activity`, provides {@link ActivityService}, and provides the
+ * {@link AuditEventSubscriber} — the **live** audit writer, which self-registers
+ * with the outbox dispatcher on bootstrap so every audited domain event becomes
+ * an `activity_events` row (Wave 3 moved auditing off in-band recording).
+ *
+ * **Global**, so any plugin can read/record without re-importing the module. It
+ * still binds `ActivityService` to the `ACTIVITY_RECORDER` token — kept for a
+ * stable public surface but **deprecated**; nothing writes through it anymore.
+ * The Drizzle client comes from `@orthacms/database`'s global `DatabaseModule`
+ * (which also provides the `OutboxDispatcher`); authorization from identity's
+ * `PermissionsGuard`.
+ */
+export declare class ActivityModule {
+    /** Creates the dynamic module: the read controller, the recorder, the subscriber. */
+    static forRoot(): DynamicModule;
+}
+//# sourceMappingURL=activity.module.d.ts.map

package/dist/lib/activity.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.module.d.ts","sourceRoot":"","sources":["../../src/lib/activity.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAU,MAAM,gBAAgB,CAAC;AAOvD;;;;;;;;;;;;;GAaG;AACH,qBACa,cAAc;IACvB,qFAAqF;IACrF,MAAM,CAAC,OAAO,IAAI,aAAa;CAiBlC"}

package/dist/lib/activity.module.js

@@ -0,0 +1,49 @@
+"use strict";
+var ActivityModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const list_activity_controller_1 = require("./activity/controllers/list-activity.controller");
+const activity_service_1 = require("./activity/services/activity.service");
+const audit_event_subscriber_1 = require("./activity/infrastructure/audit-event.subscriber");
+const activity_tool_provider_1 = require("./copilot/activity-tool.provider");
+/**
+ * NestJS module for the activity plugin. Mounts the read API under
+ * `/api/activity`, provides {@link ActivityService}, and provides the
+ * {@link AuditEventSubscriber} — the **live** audit writer, which self-registers
+ * with the outbox dispatcher on bootstrap so every audited domain event becomes
+ * an `activity_events` row (Wave 3 moved auditing off in-band recording).
+ *
+ * **Global**, so any plugin can read/record without re-importing the module. It
+ * still binds `ActivityService` to the `ACTIVITY_RECORDER` token — kept for a
+ * stable public surface but **deprecated**; nothing writes through it anymore.
+ * The Drizzle client comes from `@orthacms/database`'s global `DatabaseModule`
+ * (which also provides the `OutboxDispatcher`); authorization from identity's
+ * `PermissionsGuard`.
+ */
+let ActivityModule = ActivityModule_1 = class ActivityModule {
+    /** Creates the dynamic module: the read controller, the recorder, the subscriber. */
+    static forRoot() {
+        return {
+            module: ActivityModule_1,
+            global: true,
+            controllers: [list_activity_controller_1.ListActivityController],
+            providers: [
+                activity_service_1.ActivityService,
+                audit_event_subscriber_1.AuditEventSubscriber,
+                { provide: identity_server_1.ACTIVITY_RECORDER, useExisting: activity_service_1.ActivityService },
+                // The copilot's audit-log read. Both no-op when no copilot
+                // plugin is registered — the registrar injects the registry
+                // optionally.
+                activity_tool_provider_1.ActivityCopilotToolProvider
+            ],
+            exports: [activity_service_1.ActivityService, identity_server_1.ACTIVITY_RECORDER]
+        };
+    }
+};
+exports.ActivityModule = ActivityModule;
+exports.ActivityModule = ActivityModule = ActivityModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], ActivityModule);

package/dist/lib/copilot/activity-tool.provider.d.ts

@@ -0,0 +1,40 @@
+import { type OnModuleInit } from '@nestjs/common';
+import { ToolRegistry } from '@orthacms/tools-server';
+import type { ToolDefinition, ToolProvider } from '@orthacms/tools-server';
+import { ActivityService } from '../activity/services/activity.service';
+/**
+ * The activity plugin's contribution to the copilot's tool catalogue —
+ * `activity_recent`, a thin wrapper over the same `ActivityService.list` the
+ * read route calls.
+ *
+ * **This tool is deployment-wide, not workspace-scoped, and that is not an
+ * oversight.** `activity_events` has no workspace column: the trail records
+ * user invites, role changes and workspace lifecycle alongside content edits,
+ * and several of those events belong to no workspace at all. So there is
+ * nothing to scope by, and the tool says so in its description rather than
+ * implying a boundary it cannot enforce.
+ *
+ * What bounds it instead is `activity:read`, which the v1 role matrix grants to
+ * **admins only** — the same key guarding `GET /api/activity`. The capability
+ * profile withholds the tool from everyone else at *offer* time, so a viewer's
+ * or contributor's run is never told it exists (ADR-0005 §3). An admin asking
+ * their copilot about the audit log reads exactly what they could already read
+ * by opening the Activity page.
+ */
+export declare class ActivityCopilotToolProvider implements ToolProvider, OnModuleInit {
+    private readonly activity;
+    private readonly toolRegistry?;
+    constructor(activity: ActivityService, toolRegistry?: ToolRegistry | undefined);
+    /**
+     * Register with the shared tool registry once the DI graph is built —
+     * the same catalogue the MCP endpoint serves, narrowed to the `copilot`
+     * surface by each tool's `surfaces`. `@Optional()` because a deployment
+     * may run neither consumer, in which case these simply go unregistered.
+     */
+    onModuleInit(): void;
+    /** The one activity read tool. */
+    tools(): readonly ToolDefinition[];
+    /** `activity_recent` — a page of the audit trail, newest first. */
+    private recent;
+}
+//# sourceMappingURL=activity-tool.provider.d.ts.map

package/dist/lib/copilot/activity-tool.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-tool.provider.d.ts","sourceRoot":"","sources":["../../../src/lib/copilot/activity-tool.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEzE,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAKxE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBACa,2BAA4B,YAAW,YAAY,EAAE,YAAY;IAEtE,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACb,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;gBADzB,QAAQ,EAAE,eAAe,EACb,YAAY,CAAC,EAAE,YAAY,YAAA;IAG5D;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAIpB,kCAAkC;IAClC,KAAK,IAAI,SAAS,cAAc,EAAE;IAIlC,mEAAmE;IACnE,OAAO,CAAC,MAAM;CAwHjB"}

package/dist/lib/copilot/activity-tool.provider.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityCopilotToolProvider = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const tools_server_1 = require("@orthacms/tools-server");
+const activity_service_1 = require("../activity/services/activity.service");
+/** Events a single `activity_recent` call may return. */
+const MAX_TOOL_PAGE_SIZE = 25;
+/**
+ * The activity plugin's contribution to the copilot's tool catalogue —
+ * `activity_recent`, a thin wrapper over the same `ActivityService.list` the
+ * read route calls.
+ *
+ * **This tool is deployment-wide, not workspace-scoped, and that is not an
+ * oversight.** `activity_events` has no workspace column: the trail records
+ * user invites, role changes and workspace lifecycle alongside content edits,
+ * and several of those events belong to no workspace at all. So there is
+ * nothing to scope by, and the tool says so in its description rather than
+ * implying a boundary it cannot enforce.
+ *
+ * What bounds it instead is `activity:read`, which the v1 role matrix grants to
+ * **admins only** — the same key guarding `GET /api/activity`. The capability
+ * profile withholds the tool from everyone else at *offer* time, so a viewer's
+ * or contributor's run is never told it exists (ADR-0005 §3). An admin asking
+ * their copilot about the audit log reads exactly what they could already read
+ * by opening the Activity page.
+ */
+let ActivityCopilotToolProvider = class ActivityCopilotToolProvider {
+    activity;
+    toolRegistry;
+    constructor(activity, toolRegistry) {
+        this.activity = activity;
+        this.toolRegistry = toolRegistry;
+    }
+    /**
+     * Register with the shared tool registry once the DI graph is built —
+     * the same catalogue the MCP endpoint serves, narrowed to the `copilot`
+     * surface by each tool's `surfaces`. `@Optional()` because a deployment
+     * may run neither consumer, in which case these simply go unregistered.
+     */
+    onModuleInit() {
+        this.toolRegistry?.register(this);
+    }
+    /** The one activity read tool. */
+    tools() {
+        return [this.recent()];
+    }
+    /** `activity_recent` — a page of the audit trail, newest first. */
+    recent() {
+        return {
+            name: 'activity_recent',
+            title: 'Recent activity',
+            description: 'Read the audit trail — who did what, when. Filter by event kind ' +
+                '(e.g. "entry.published"), by the subject acted upon, by actor, or by a time ' +
+                'window. Newest first. This log covers the whole deployment, not just the ' +
+                'current workspace, and it includes account and workspace administration as ' +
+                'well as content changes, so say which scope you are reporting on.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    kind: {
+                        type: 'array',
+                        items: { type: 'string', maxLength: 255 },
+                        description: 'Event kinds to include, matched exactly (e.g. ["entry.published"]). ' +
+                            'Kinds are owned by the emitting plugins — read one off a result ' +
+                            'rather than guessing.'
+                    },
+                    subjectType: {
+                        type: 'string',
+                        maxLength: 255,
+                        description: 'Restrict to one kind of subject, e.g. "user" or "entry".'
+                    },
+                    subjectId: {
+                        type: 'string',
+                        maxLength: 255,
+                        description: 'Restrict to one entity’s history — e.g. an entry id, to see ' +
+                            'everything that happened to it.'
+                    },
+                    actorEmail: {
+                        type: 'string',
+                        maxLength: 255,
+                        description: 'Case-insensitive substring of the actor’s email, as recorded at ' +
+                            'the time. Use this rather than a user id when the question names ' +
+                            'a person.'
+                    },
+                    from: {
+                        type: 'string',
+                        description: 'Inclusive lower bound on the event time, ISO 8601 (e.g. "2026-01-01T00:00:00Z").'
+                    },
+                    to: {
+                        type: 'string',
+                        description: 'Inclusive upper bound on the event time, ISO 8601.'
+                    },
+                    page: {
+                        type: 'integer',
+                        minimum: 1,
+                        description: '1-based page number.'
+                    },
+                    pageSize: {
+                        type: 'integer',
+                        minimum: 1,
+                        maximum: MAX_TOOL_PAGE_SIZE,
+                        description: `Events per page (max ${MAX_TOOL_PAGE_SIZE}).`
+                    }
+                },
+                additionalProperties: false
+            },
+            requires: [identity_server_1.PERMISSIONS.ACTIVITY_READ],
+            readOnly: true,
+            effect: 'read',
+            surfaces: ['copilot'],
+            handler: async (input) => {
+                const args = (input ?? {});
+                // Clamped here as well as declared in the schema: the
+                // validator is defence in depth, not the boundary.
+                const pageSize = Math.min(Math.max(args.pageSize ?? 10, 1), MAX_TOOL_PAGE_SIZE);
+                const result = await this.activity.list({
+                    ...(args.kind?.length ? { kind: args.kind } : {}),
+                    ...(args.subjectType
+                        ? { subjectType: args.subjectType }
+                        : {}),
+                    ...(args.subjectId ? { subjectId: args.subjectId } : {}),
+                    ...(args.actorEmail ? { actorEmail: args.actorEmail } : {}),
+                    ...(args.from ? { from: args.from } : {}),
+                    ...(args.to ? { to: args.to } : {}),
+                    page: Math.max(args.page ?? 1, 1),
+                    pageSize,
+                    sort: 'at',
+                    order: 'desc'
+                });
+                return {
+                    total: result.total,
+                    page: result.page,
+                    pageSize: result.pageSize,
+                    // `meta` is an open per-kind payload each plugin owns, and
+                    // some of it is user-authored text. It rides through the
+                    // engine's untrusted-content fence like any other tool
+                    // output, so it is passed on rather than stripped — the
+                    // fence is what makes that safe, not omission.
+                    items: result.items.map((event) => ({
+                        ...event,
+                        at: event.at.toISOString()
+                    }))
+                };
+            }
+        };
+    }
+};
+exports.ActivityCopilotToolProvider = ActivityCopilotToolProvider;
+exports.ActivityCopilotToolProvider = ActivityCopilotToolProvider = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(1, (0, common_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [activity_service_1.ActivityService,
+        tools_server_1.ToolRegistry])
+], ActivityCopilotToolProvider);

package/dist/lib/schema/activity-events.d.ts

@@ -0,0 +1,178 @@
+/**
+ * The append-only audit trail. One row per recorded action.
+ *
+ * Deliberate isolation choices (the audit log must outlive what it records):
+ * - `actorId` is a uuid with **no FK** — the actor may later be deleted, but
+ *   the audit row must remain.
+ * - `actorEmail` is a frozen snapshot of the actor's email at record time, so
+ *   the trail stays readable even after the user row is gone or renamed.
+ * - `subjectId` is **text**, not uuid — subjects are not always users and not
+ *   always uuid-keyed.
+ * - `meta` is an open jsonb payload; each emitting plugin owns its shape.
+ * - `at` is the logical event time (defaults to now); `createdAt` is the
+ *   immutable write time, dropped from the read API.
+ *
+ * Indexed for the three query shapes the read API serves: a subject's history,
+ * an actor's history, and a kind's history — each time-ordered.
+ */
+export declare const activityEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "activity_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "activity_events";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "activity_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subjectType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subject_type";
+            tableName: "activity_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subjectId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subject_id";
+            tableName: "activity_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        actorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "actor_id";
+            tableName: "activity_events";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        actorEmail: import("drizzle-orm/pg-core").PgColumn<{
+            name: "actor_email";
+            tableName: "activity_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        meta: import("drizzle-orm/pg-core").PgColumn<{
+            name: "meta";
+            tableName: "activity_events";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "at";
+            tableName: "activity_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "activity_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=activity-events.d.ts.map

package/dist/lib/schema/activity-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-events.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/activity-events.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB1B,CAAC"}