@orthacms/content-server 0.4.3 → 0.5.0

package/dist/lib/docs/views-schemas.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * The OpenAPI schemas the **saved views** plugin contributes.
+ *
+ * `SavedView` is a plain TypeScript `interface` in `views/domain/`, which the
+ * swagger scanner cannot see and ADR-0003 forbids decorating — so the shape is
+ * written out here instead, the same way the content types are.
+ *
+ * One thing about it is runtime data rather than a fixed contract: `scope` is
+ * `content:<typeName>`, and which type names exist is what the host registered.
+ * {@link buildViewsSchemas} therefore takes the serialized registry and turns
+ * the scope into an enum of the real lists, so a reader of the reference sees
+ * `content:article`, not "some string".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAVED_VIEW_PAYLOAD_SCHEMA = exports.SAVED_VIEW_SCHEMA = void 0;
+exports.buildViewsSchemas = buildViewsSchemas;
+const content_schemas_1 = require("./content-schemas");
+const saved_view_1 = require("../views/domain/saved-view");
+const views_constants_1 = require("../views/views.constants");
+const entries_constants_1 = require("../entries/entries.constants");
+/** Schema name of one saved view. */
+exports.SAVED_VIEW_SCHEMA = 'SavedView';
+/** Schema name of the slice a view restores. */
+exports.SAVED_VIEW_PAYLOAD_SCHEMA = 'SavedViewPayload';
+/**
+ * The `scope` values the API will accept and return.
+ *
+ * An enum when the host registered types, a plain bounded string when it
+ * registered none — an empty `enum` would be a schema nothing can satisfy, and
+ * "no views are reachable" is better said by the absence of types than by a
+ * response schema that rejects every answer.
+ */
+function scopeSchema(types) {
+    const base = {
+        type: 'string',
+        maxLength: views_constants_1.VIEW_SCOPE_MAX_LENGTH,
+        description: `The list this view belongs to, as \`${views_constants_1.CONTENT_SCOPE_PREFIX}<typeName>\`. A scope naming a type this workspace was not granted is a 404 — the same answer an unknown type gives, so the endpoint cannot be used to discover which types exist elsewhere.`
+    };
+    if (types.length === 0) {
+        return base;
+    }
+    return {
+        ...base,
+        enum: types.map((type) => `${views_constants_1.CONTENT_SCOPE_PREFIX}${type.name}`)
+    };
+}
+/**
+ * The stored slice.
+ *
+ * `filter` and `sort` are the records page's own `?filter=` / `?sort=` strings
+ * carried verbatim, so this describes them as the strings they are rather than
+ * re-modelling a filter tree that would then have two spellings. `search` and
+ * `page` are absent by design — see {@link SavedViewPayload}.
+ */
+function payloadSchema() {
+    return {
+        type: 'object',
+        title: 'Saved view payload',
+        description: 'The filter/sort/columns/page-size slice a view restores. Mirrors the records page’s URL params, so a saved view and a hand-edited link replay through one code path. A one-off `search` and the reading position `page` are deliberately not part of a view.',
+        properties: {
+            filter: {
+                type: 'string',
+                maxLength: entries_constants_1.FILTER_MAX_LENGTH,
+                description: 'The filter tree as a JSON string, byte-identical to `?filter=`. Stored opaquely and re-validated against the type when replayed.'
+            },
+            sort: {
+                type: 'string',
+                maxLength: 255,
+                description: 'Sort spec: a column id (ascending) or `-`-prefixed (descending).'
+            },
+            pageSize: {
+                type: 'integer',
+                minimum: 1,
+                maximum: entries_constants_1.MAX_PAGE_SIZE,
+                description: 'Rows per page this view opens with.'
+            },
+            columns: {
+                type: 'array',
+                maxItems: views_constants_1.VIEW_MAX_COLUMNS,
+                items: { type: 'string', maxLength: views_constants_1.VIEW_COLUMN_MAX_LENGTH },
+                description: 'Visible column ids **in display order**. Ids the type no longer has are dropped when the view is applied.'
+            },
+            extra: {
+                type: 'object',
+                additionalProperties: { type: 'string' },
+                description: 'Slot-contributed list params (the i18n plugin’s `locale`, and whatever a later plugin adds), as a flat string map. Opaque on purpose — the keys come from plugin-registered toolbar items at runtime.'
+            }
+        },
+        // Every field is optional: a view over an unfiltered, unsorted,
+        // default-column list stores `{}`, and that is a legitimate view.
+        additionalProperties: false
+    };
+}
+/** One saved view, as every one of these routes answers it. */
+function savedViewSchema(types) {
+    const properties = {
+        id: { type: 'string', format: 'uuid', description: 'View id.' },
+        scope: scopeSchema(types),
+        name: {
+            type: 'string',
+            minLength: 1,
+            maxLength: views_constants_1.VIEW_NAME_MAX_LENGTH,
+            description: 'Display name. Unique per person within one workspace and scope.'
+        },
+        visibility: {
+            type: 'string',
+            enum: [...saved_view_1.VIEW_VISIBILITY_VALUES],
+            description: '`private` (only its owner) or `workspace` (every member). Sharing needs `views:share`.'
+        },
+        ownerId: {
+            type: 'string',
+            format: 'uuid',
+            description: 'The user who created it.'
+        },
+        isOwn: {
+            type: 'boolean',
+            description: 'Whether the **caller** owns it. Computed per request, so the same row answers differently to two people — the admin gates Save and Delete on it.'
+        },
+        isDefault: {
+            type: 'boolean',
+            description: 'Whether it is the caller’s default for this scope. Also per-caller: a default is a personal landing choice, not a property of the view.'
+        },
+        payload: (0, content_schemas_1.ref)(exports.SAVED_VIEW_PAYLOAD_SCHEMA),
+        updatedAt: {
+            type: 'string',
+            format: 'date-time',
+            description: 'Last modified, ISO-8601.'
+        }
+    };
+    return {
+        type: 'object',
+        title: 'Saved view',
+        description: 'A named slice of one content list. The stored payload is **not** a grant: it is replayed through the ordinary list query with the reader’s own permissions, workspace scope and content grants, so a shared view shows a narrower reader fewer rows — never more.',
+        properties,
+        required: [
+            'id',
+            'scope',
+            'name',
+            'visibility',
+            'ownerId',
+            'isOwn',
+            'isDefault',
+            'payload',
+            'updatedAt'
+        ],
+        additionalProperties: false
+    };
+}
+/** The saved-view schemas, keyed by schema name. */
+function buildViewsSchemas(types) {
+    return {
+        [exports.SAVED_VIEW_PAYLOAD_SCHEMA]: payloadSchema(),
+        [exports.SAVED_VIEW_SCHEMA]: savedViewSchema(types)
+    };
+}

package/dist/lib/entries/application/use-cases/bulk-publish-entries.use-case.d.ts

@@ -1,4 +1,4 @@
-import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import { type EventActor, OutboxWriter, UnitOfWork } from '@orthacms/database';
 import type { AnyContentType } from '../../../types/content-type';
 import { EntryValidationService } from '../../../validation/services/entry-validation.service';
 import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
@@ -11,6 +11,12 @@ import { type BulkPublishResult } from '../../types/bulk-publish';
  * `publishable` ids, reporting which were skipped and why (partial success),
  * and appends one `entry.published` event per newly-published id to the outbox —
  * atomically with the batch.
+ *
+ * `actor` is stamped onto every one of those events. It used to be missing here
+ * while the single-entry publish and the bulk *delete* beside it both carried
+ * one, so publishing fifty entries from the records toolbar wrote fifty audit
+ * rows attributed to "System" — the one operation in the content lifecycle that
+ * silently lost the person who performed it.
  */
 export declare class BulkPublishEntriesUseCase {
     private readonly uow;
@@ -18,6 +24,6 @@ export declare class BulkPublishEntriesUseCase {
     private readonly writer;
     private readonly validation;
     constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService, validation: EntryValidationService);
-    execute(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkPublishResult>;
+    execute(type: AnyContentType, ids: string[], workspaceId: string, actor?: EventActor): Promise<BulkPublishResult>;
 }
 //# sourceMappingURL=bulk-publish-entries.use-case.d.ts.map

package/dist/lib/entries/application/use-cases/bulk-publish-entries.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bulk-publish-entries.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/bulk-publish-entries.use-case.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGhF;;;;;;;;GAQG;AACH,qBACa,yBAAyB;IAE9B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAHV,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,sBAAsB;IAGjD,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,iBAAiB,CAAC;CA6DhC"}
+{"version":3,"file":"bulk-publish-entries.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/bulk-publish-entries.use-case.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,KAAK,UAAU,EACf,YAAY,EACZ,UAAU,EACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIhF;;;;;;;;;;;;;;GAcG;AACH,qBACa,yBAAyB;IAE9B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAHV,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,sBAAsB;IAGjD,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,UAAU,GACnB,OAAO,CAAC,iBAAiB,CAAC;CAqEhC"}

package/dist/lib/entries/application/use-cases/bulk-publish-entries.use-case.js

@@ -10,6 +10,7 @@ const entry_writer_service_1 = require("../../infrastructure/persistence/entry-w
 const bulk_publish_verdicts_1 = require("../../infrastructure/persistence/bulk-publish-verdicts");
 const bulk_publish_1 = require("../../types/bulk-publish");
 const entry_1 = require("../../domain/entry");
+const entry_row_1 = require("../../infrastructure/persistence/entry-row");
 /**
  * Commit a bulk publish. Preserves the original single **locked** transaction:
  * the candidate rows are selected `FOR UPDATE` and re-validated inside one
@@ -18,6 +19,12 @@ const entry_1 = require("../../domain/entry");
  * `publishable` ids, reporting which were skipped and why (partial success),
  * and appends one `entry.published` event per newly-published id to the outbox —
  * atomically with the batch.
+ *
+ * `actor` is stamped onto every one of those events. It used to be missing here
+ * while the single-entry publish and the bulk *delete* beside it both carried
+ * one, so publishing fifty entries from the records toolbar wrote fifty audit
+ * rows attributed to "System" — the one operation in the content lifecycle that
+ * silently lost the person who performed it.
  */
 let BulkPublishEntriesUseCase = class BulkPublishEntriesUseCase {
     uow;
@@ -30,7 +37,7 @@ let BulkPublishEntriesUseCase = class BulkPublishEntriesUseCase {
         this.writer = writer;
         this.validation = validation;
     }
-    async execute(type, ids, workspaceId) {
+    async execute(type, ids, workspaceId, actor) {
         if (!type.publishable) {
             throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
         }
@@ -50,15 +57,23 @@ let BulkPublishEntriesUseCase = class BulkPublishEntriesUseCase {
                 for (const id of published) {
                     await this.writer.markRevisionPublished(exec, id, workspaceId);
                 }
-                await this.outbox.append(published.flatMap((id) => {
+                const events = published.flatMap((id) => {
                     const entry = entry_1.Entry.rehydrate({
                         id,
                         contentType: type.name,
-                        status: content_domain_1.ENTRY_STATUS.Draft
+                        status: content_domain_1.ENTRY_STATUS.Draft,
+                        workspaceId,
+                        // The candidate rows were already locked and loaded for
+                        // re-validation, so each row's own label is to hand.
+                        title: (() => {
+                            const row = byId.get(id);
+                            return row ? (0, entry_row_1.entryTitle)(type, row) : null;
+                        })()
                     });
                     entry.publish({ valid: true, issues: [] });
                     return entry.pullEvents();
-                }));
+                });
+                await this.outbox.append(actor ? (0, database_1.attachActor)(events, actor) : events);
             }
             const skipped = items
                 .filter((item) => item.verdict !== bulk_publish_1.BULK_VERDICT.Publishable)

package/dist/lib/entries/application/use-cases/bulk-unpublish-entries.use-case.d.ts

@@ -1,4 +1,4 @@
-import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import { type EventActor, OutboxWriter, UnitOfWork } from '@orthacms/database';
 import type { AnyContentType } from '../../../types/content-type';
 import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
 import type { BulkActionResult } from '../../types/bulk-publish';
@@ -18,6 +18,6 @@ export declare class BulkUnpublishEntriesUseCase {
     private readonly outbox;
     private readonly writer;
     constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService);
-    execute(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkActionResult>;
+    execute(type: AnyContentType, ids: string[], workspaceId: string, actor?: EventActor): Promise<BulkActionResult>;
 }
 //# sourceMappingURL=bulk-unpublish-entries.use-case.d.ts.map

package/dist/lib/entries/application/use-cases/bulk-unpublish-entries.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bulk-unpublish-entries.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/bulk-unpublish-entries.use-case.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAC3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE;;;;;;;;;;GAUG;AACH,qBACa,2BAA2B;IAEhC,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFN,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB;IAGzC,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,CAAC;CA+C/B"}
+{"version":3,"file":"bulk-unpublish-entries.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/bulk-unpublish-entries.use-case.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,KAAK,UAAU,EACf,YAAY,EACZ,UAAU,EACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAC3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAIjE;;;;;;;;;;GAUG;AACH,qBACa,2BAA2B;IAEhC,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFN,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB;IAGzC,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,UAAU,GACnB,OAAO,CAAC,gBAAgB,CAAC;CA6D/B"}

package/dist/lib/entries/application/use-cases/bulk-unpublish-entries.use-case.js

@@ -7,6 +7,7 @@ const database_1 = require("@orthacms/database");
 const content_domain_1 = require("@orthacms/content-domain");
 const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
 const entry_1 = require("../../domain/entry");
+const entry_row_1 = require("../../infrastructure/persistence/entry-row");
 /**
  * Revert a set of live entries to draft. Runs inside one {@link UnitOfWork}, and
  * **one set of ids runs through all three effects**: the `{ count }` reported,
@@ -27,7 +28,7 @@ let BulkUnpublishEntriesUseCase = class BulkUnpublishEntriesUseCase {
         this.outbox = outbox;
         this.writer = writer;
     }
-    async execute(type, ids, workspaceId) {
+    async execute(type, ids, workspaceId, actor) {
         if (!type.publishable) {
             throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
         }
@@ -38,21 +39,30 @@ let BulkUnpublishEntriesUseCase = class BulkUnpublishEntriesUseCase {
             // The set that actually transitions (published → draft), captured
             // before the write so we emit one event per real change.
             const publishedIds = await this.writer.publishedIdsAmong(exec, type, ids, workspaceId);
+            // Read the labels **before** the write: an audit row carries a
+            // frozen title, and after `markDraftBulk` the rows are still there
+            // but a later kind (a purge) would have taken them, so reading them
+            // up front is the habit that keeps every bulk path the same shape.
+            const byId = await this.writer.loadLiveByIds(type, publishedIds, workspaceId, exec);
             const count = await this.writer.markDraftBulk(exec, type, ids, workspaceId);
             // Revert each really-transitioned entry's published revision back to
             // draft — the same set the outbox emits an event for.
             for (const id of publishedIds) {
                 await this.writer.markRevisionUnpublished(exec, id, workspaceId);
             }
-            await this.outbox.append(publishedIds.flatMap((id) => {
+            const events = publishedIds.flatMap((id) => {
+                const row = byId.get(id);
                 const entry = entry_1.Entry.rehydrate({
                     id,
                     contentType: type.name,
-                    status: content_domain_1.ENTRY_STATUS.Published
+                    status: content_domain_1.ENTRY_STATUS.Published,
+                    workspaceId,
+                    title: row ? (0, entry_row_1.entryTitle)(type, row) : null
                 });
                 entry.unpublish();
                 return entry.pullEvents();
-            }));
+            });
+            await this.outbox.append(actor ? (0, database_1.attachActor)(events, actor) : events);
             return { count };
         });
     }

package/dist/lib/entries/application/use-cases/publish-entry.use-case.d.ts

@@ -1,4 +1,4 @@
-import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import { type EventActor, OutboxWriter, UnitOfWork } from '@orthacms/database';
 import type { AnyContentType } from '../../../types/content-type';
 import { EntryValidationService } from '../../../validation/services/entry-validation.service';
 import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
@@ -23,14 +23,12 @@ export declare class PublishEntryUseCase {
     constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService, validation: EntryValidationService);
     execute(type: AnyContentType, id: string, workspaceId: string, 
     /**
-     * The acting user, merged onto the outbox events so the audit log can
-     * name who did this. Without it every content row in the activity log
-     * read "System".
+     * The acting principal, merged onto the outbox events so the audit log
+     * can name who did this. Without it every content row in the activity
+     * log read "System" — which is also what a token-authenticated publish
+     * read as until `actor_type` let a credential be named.
      */
-    actor?: {
-        id: string;
-        email: string | null;
-    }, 
+    actor?: EventActor, 
     /**
      * The version to mark live, when publishing a **specific** earlier one
      * whose content the caller already re-applied to the live row. Omitted

package/dist/lib/entries/application/use-cases/publish-entry.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publish-entry.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/publish-entry.use-case.ts"],"names":[],"mappings":"AAMA,OAAO,EAAe,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAI/D;;;;;;;;;;;GAWG;AACH,qBACa,mBAAmB;IAExB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAHV,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,sBAAsB;IAGjD,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM;IACnB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;IAC5C;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,WAAW,CAAC;IA2EvB,OAAO,CAAC,QAAQ;CAKnB"}
+{"version":3,"file":"publish-entry.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/publish-entry.use-case.ts"],"names":[],"mappings":"AAMA,OAAO,EAEH,KAAK,UAAU,EACf,YAAY,EACZ,UAAU,EACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAK/D;;;;;;;;;;;GAWG;AACH,qBACa,mBAAmB;IAExB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAHV,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,sBAAsB;IAGjD,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM;IACnB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,UAAU;IAClB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,WAAW,CAAC;IA+EvB,OAAO,CAAC,QAAQ;CAKnB"}

package/dist/lib/entries/application/use-cases/publish-entry.use-case.js

@@ -7,6 +7,7 @@ const database_1 = require("@orthacms/database");
 const entry_validation_service_1 = require("../../../validation/services/entry-validation.service");
 const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
 const entry_row_1 = require("../../infrastructure/persistence/entry-row");
+const entry_row_2 = require("../../infrastructure/persistence/entry-row");
 const entry_1 = require("../../domain/entry");
 const entry_publish_blocked_error_1 = require("../../domain/entry-publish-blocked.error");
 /**
@@ -34,9 +35,10 @@ let PublishEntryUseCase = class PublishEntryUseCase {
     }
     async execute(type, id, workspaceId, 
     /**
-     * The acting user, merged onto the outbox events so the audit log can
-     * name who did this. Without it every content row in the activity log
-     * read "System".
+     * The acting principal, merged onto the outbox events so the audit log
+     * can name who did this. Without it every content row in the activity
+     * log read "System" — which is also what a token-authenticated publish
+     * read as until `actor_type` let a credential be named.
      */
     actor, 
     /**
@@ -63,7 +65,11 @@ let PublishEntryUseCase = class PublishEntryUseCase {
             const entry = entry_1.Entry.rehydrate({
                 id,
                 contentType: type.name,
-                status: current['status']
+                status: current['status'],
+                workspaceId,
+                // The stored row is already loaded, so the audit row gets a
+                // readable name for free rather than a bare uuid.
+                title: (0, entry_row_2.entryTitle)(type, current)
             });
             try {
                 entry.publish({ valid: issues.length === 0, issues });

package/dist/lib/entries/application/use-cases/unpublish-entry.use-case.d.ts

@@ -1,4 +1,4 @@
-import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import { type EventActor, OutboxWriter, UnitOfWork } from '@orthacms/database';
 import type { AnyContentType } from '../../../types/content-type';
 import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
 import type { EntryRecord } from '../../types/entry-list-view';
@@ -21,10 +21,7 @@ export declare class UnpublishEntryUseCase {
      * name who did this. Without it every content row in the activity log
      * read "System".
      */
-    actor?: {
-        id: string;
-        email: string | null;
-    }): Promise<EntryRecord>;
+    actor?: EventActor): Promise<EntryRecord>;
     private notFound;
 }
 //# sourceMappingURL=unpublish-entry.use-case.d.ts.map

package/dist/lib/entries/application/use-cases/unpublish-entry.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unpublish-entry.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/unpublish-entry.use-case.ts"],"names":[],"mappings":"AAKA,OAAO,EAAe,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D;;;;;;;GAOG;AACH,qBACa,qBAAqB;IAE1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFN,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB;IAGzC,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM;IACnB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAC7C,OAAO,CAAC,WAAW,CAAC;IA0CvB,OAAO,CAAC,QAAQ;CAKnB"}
+{"version":3,"file":"unpublish-entry.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/unpublish-entry.use-case.ts"],"names":[],"mappings":"AAKA,OAAO,EAEH,KAAK,UAAU,EACf,YAAY,EACZ,UAAU,EACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAI/D;;;;;;;GAOG;AACH,qBACa,qBAAqB;IAE1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFN,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB;IAGzC,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM;IACnB;;;;OAIG;IACH,KAAK,CAAC,EAAE,UAAU,GACnB,OAAO,CAAC,WAAW,CAAC;IA8CvB,OAAO,CAAC,QAAQ;CAKnB"}

package/dist/lib/entries/application/use-cases/unpublish-entry.use-case.js

@@ -6,6 +6,7 @@ const common_1 = require("@nestjs/common");
 const database_1 = require("@orthacms/database");
 const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
 const entry_row_1 = require("../../infrastructure/persistence/entry-row");
+const entry_row_2 = require("../../infrastructure/persistence/entry-row");
 const entry_1 = require("../../domain/entry");
 /**
  * Revert one entry to draft. Runs inside a {@link UnitOfWork} so the status
@@ -42,7 +43,11 @@ let UnpublishEntryUseCase = class UnpublishEntryUseCase {
             const entry = entry_1.Entry.rehydrate({
                 id,
                 contentType: type.name,
-                status: current['status']
+                status: current['status'],
+                workspaceId,
+                // The stored row is already loaded, so the audit row gets a
+                // readable name for free rather than a bare uuid.
+                title: (0, entry_row_2.entryTitle)(type, current)
             });
             entry.unpublish();
             const updated = await this.writer.markDraft(exec, type, id, workspaceId);

package/dist/lib/entries/domain/entry.d.ts

@@ -8,6 +8,13 @@ export interface EntryState {
     contentType: string;
     /** Current publish status of the stored row. */
     status: EntryStatus;
+    /** The workspace the row lives in — carried only for the event payload. */
+    workspaceId?: string | null;
+    /**
+     * A human label for the entry, carried only for the event payload so the
+     * audit row names something a reader recognises instead of a uuid.
+     */
+    title?: string | null;
 }
 /**
  * The outcome of the publish precondition, computed by the use-case from the
@@ -37,7 +44,7 @@ export interface PublishGate {
  */
 export declare class Entry {
     private readonly _id;
-    private readonly _contentType;
+    private readonly _subject;
     private _status;
     private readonly events;
     private constructor();

package/dist/lib/entries/domain/entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/domain/entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAGH,KAAK,WAAW,EAChB,KAAK,eAAe,EACvB,MAAM,0BAA0B,CAAC;AAIlC,oFAAoF;AACpF,MAAM,WAAW,UAAU;IACvB,gBAAgB;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,MAAM,EAAE,WAAW,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,qCAAqC;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,MAAM,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,KAAK;IAIV,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,OAAO;IALnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAE5C,OAAO;IAMP,gEAAgE;IAChE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK;IAI1C;;;;;;;;OAQG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAchC;;;;;OAKG;IACH,SAAS,IAAI,IAAI;IAWjB,oBAAoB;IACpB,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,kCAAkC;IAClC,IAAI,MAAM,IAAI,WAAW,CAExB;IAED,gEAAgE;IAChE,UAAU,IAAI,WAAW,EAAE;IAI3B,OAAO,CAAC,KAAK;CAGhB"}
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/domain/entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAGH,KAAK,WAAW,EAChB,KAAK,eAAe,EACvB,MAAM,0BAA0B,CAAC;AASlC,oFAAoF;AACpF,MAAM,WAAW,UAAU;IACvB,gBAAgB;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,MAAM,EAAE,WAAW,CAAC;IACpB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,qCAAqC;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,MAAM,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,KAAK;IAIV,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,OAAO;IALnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAE5C,OAAO;IAMP,gEAAgE;IAChE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK;IAY1C;;;;;;;;OAQG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAYhC;;;;;OAKG;IACH,SAAS,IAAI,IAAI;IASjB,oBAAoB;IACpB,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,kCAAkC;IAClC,IAAI,MAAM,IAAI,WAAW,CAExB;IAED,gEAAgE;IAChE,UAAU,IAAI,WAAW,EAAE;IAI3B,OAAO,CAAC,KAAK;CAKhB"}

package/dist/lib/entries/domain/entry.js

@@ -21,17 +21,21 @@ const entry_publish_blocked_error_1 = require("./entry-publish-blocked.error");
  */
 class Entry {
     _id;
-    _contentType;
+    _subject;
     _status;
     events = [];
-    constructor(_id, _contentType, _status) {
+    constructor(_id, _subject, _status) {
         this._id = _id;
-        this._contentType = _contentType;
+        this._subject = _subject;
         this._status = _status;
     }
     /** Reconstructs an entry from its persisted lifecycle state. */
     static rehydrate(state) {
-        return new Entry(state.id, state.contentType, state.status);
+        return new Entry(state.id, {
+            contentType: state.contentType,
+            workspaceId: state.workspaceId ?? null,
+            title: state.title ?? null
+        }, state.status);
     }
     /**
      * Publish the entry. Rejects with {@link EntryPublishBlockedError} when the
@@ -51,9 +55,7 @@ class Entry {
         }
         (0, content_domain_1.assertTransition)(this._status, content_domain_1.ENTRY_STATUS.Published);
         this._status = content_domain_1.ENTRY_STATUS.Published;
-        this.raise(entry_events_1.ENTRY_EVENT_KINDS.PUBLISHED, {
-            contentType: this._contentType
-        });
+        this.raise(entry_events_1.ENTRY_EVENT_KINDS.PUBLISHED);
     }
     /**
      * Revert the entry to draft. A `published` row transitions to `draft` via
@@ -67,9 +69,7 @@ class Entry {
         }
         (0, content_domain_1.assertTransition)(this._status, content_domain_1.ENTRY_STATUS.Draft);
         this._status = content_domain_1.ENTRY_STATUS.Draft;
-        this.raise(entry_events_1.ENTRY_EVENT_KINDS.UNPUBLISHED, {
-            contentType: this._contentType
-        });
+        this.raise(entry_events_1.ENTRY_EVENT_KINDS.UNPUBLISHED);
     }
     /** The entry id. */
     get id() {
@@ -83,8 +83,8 @@ class Entry {
     pullEvents() {
         return this.events.splice(0, this.events.length);
     }
-    raise(kind, payload) {
-        this.events.push((0, entry_events_1.entryEvent)(kind, this._id, payload));
+    raise(kind) {
+        this.events.push((0, entry_events_1.entryEvent)(kind, this._id, (0, entry_events_1.entrySubjectPayload)(this._subject)));
     }
 }
 exports.Entry = Entry;

package/dist/lib/entries/domain/events/entry-events.d.ts

@@ -26,6 +26,48 @@ export declare const ENTRY_EVENT_KINDS: {
     readonly RESTORED: "entry.restored";
     readonly PURGED: "entry.purged";
 };
+/**
+ * What an entry event says about **which entry** it is about, beyond the id.
+ *
+ * Both extra fields exist because of what an audit row can and cannot recover
+ * afterwards:
+ *
+ * - `workspaceId` is the only way the trail can answer a workspace-shaped
+ *   question. `activity_events` grew a nullable `workspace_id` for it, filled
+ *   from the event payload, and an entry is the most-produced audited fact in
+ *   the product — so an entry event that omitted it would leave the column
+ *   mostly empty and the question mostly unanswerable.
+ * - `title` is what makes the row **readable**. An audit row keeps no FK and no
+ *   denormalised name; its whole handle on the subject is `subject_id`. That is
+ *   survivable for an entry that still exists and unrecoverable for one that
+ *   does not — and `entry.purged` is precisely the case where this row is the
+ *   only remaining record of the thing. A uuid is not an answer to "what did
+ *   they delete".
+ *
+ * Both are optional so a caller that genuinely has neither (a unit test, an
+ * event minted outside the write path) is not forced to invent them.
+ */
+export interface EntrySubject {
+    /** The content type's machine name. */
+    contentType: string;
+    /** The workspace the entry lives in. */
+    workspaceId?: string | null;
+    /**
+     * A human label for the entry **at the time of the event** — a frozen
+     * snapshot, like `actor_email`, not a lookup. The point is to survive the
+     * subject.
+     */
+    title?: string | null;
+}
+/**
+ * The subject fields every entry event's payload carries.
+ *
+ * Exported because the {@link Entry} model raises its two events through the
+ * envelope builder directly rather than the per-kind helpers — those two are
+ * status transitions the model owns, and it must produce the same payload shape
+ * as the five the write path mints.
+ */
+export declare function entrySubjectPayload(subject: EntrySubject): Record<string, unknown>;
 /**
  * Builds an entry {@link DomainEvent} of `kind` for `entryId`, carrying
  * `payload`. Keeps the domain model free of the event envelope's plumbing — the
@@ -33,7 +75,7 @@ export declare const ENTRY_EVENT_KINDS: {
  */
 export declare function entryEvent(kind: string, entryId: string, payload: Record<string, unknown>): DomainEvent;
 /** A new entry exists. `contentType` is what lets the log name *what* was made. */
-export declare function entryCreated(entryId: string, contentType: string): DomainEvent;
+export declare function entryCreated(entryId: string, subject: EntrySubject): DomainEvent;
 /**
  * An entry's stored values changed, naming **which fields** did.
  *
@@ -46,16 +88,16 @@ export declare function entryCreated(entryId: string, contentType: string): Doma
  * and therefore no event at all, so the log records editorial changes rather
  * than round trips.
  */
-export declare function entryUpdated(entryId: string, contentType: string, fields: readonly string[]): DomainEvent;
+export declare function entryUpdated(entryId: string, subject: EntrySubject, fields: readonly string[]): DomainEvent;
 /**
  * An entry was deleted. `soft` distinguishes the two very different facts the
  * one route produces: a **paranoid** type is tombstoned and can be restored,
  * while any other type is gone from the table the moment this commits, and a
  * reviewer reading the log needs to know which happened.
  */
-export declare function entryDeleted(entryId: string, contentType: string, soft: boolean): DomainEvent;
+export declare function entryDeleted(entryId: string, subject: EntrySubject, soft: boolean): DomainEvent;
 /** A soft-deleted entry's tombstone was cleared. */
-export declare function entryRestored(entryId: string, contentType: string): DomainEvent;
+export declare function entryRestored(entryId: string, subject: EntrySubject): DomainEvent;
 /**
  * A tombstoned entry was destroyed permanently.
  *
@@ -63,5 +105,5 @@ export declare function entryRestored(entryId: string, contentType: string): Dom
  * action with nothing left behind to inspect afterwards, so it is exactly the
  * one an audit trail has to record distinctly.
  */
-export declare function entryPurged(entryId: string, contentType: string): DomainEvent;
+export declare function entryPurged(entryId: string, subject: EntrySubject): DomainEvent;
 //# sourceMappingURL=entry-events.d.ts.map

package/dist/lib/entries/domain/events/entry-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-events.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/domain/events/entry-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;CAQpB,CAAC;AAKX;;;;GAIG;AACH,wBAAgB,UAAU,CACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,WAAW,CAOb;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GACpB,WAAW,CAEb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,SAAS,MAAM,EAAE,GAC1B,WAAW,CAKb;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,OAAO,GACd,WAAW,CAKb;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CACzB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GACpB,WAAW,CAEb;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW,CAE7E"}
+{"version":3,"file":"entry-events.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/domain/events/entry-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;CAQpB,CAAC;AAKX;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,YAAY;IACzB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,YAAY,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMzB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,WAAW,CAOb;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,GACtB,WAAW,CAMb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,SAAS,MAAM,EAAE,GAC1B,WAAW,CAKb;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,OAAO,GACd,WAAW,CAKb;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CACzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,GACtB,WAAW,CAMb;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,GACtB,WAAW,CAMb"}