@orthacms/content-server 0.0.0-reserve.0

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

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentCopilotToolProvider = 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 content_tokens_1 = require("../content.tokens");
+const entries_service_1 = require("../entries/infrastructure/queries/entries.service");
+const entry_writer_service_1 = require("../entries/infrastructure/persistence/entry-writer.service");
+const workspace_grants_query_1 = require("../content-types/queries/workspace-grants.query");
+const entries_constants_1 = require("../entries/entries.constants");
+const entry_filter_surface_1 = require("../entries/infrastructure/queries/entry-filter-surface");
+const filter_schema_1 = require("./filter-schema");
+const project_entry_1 = require("./project-entry");
+/** Rows a single `admin_content_search` call may return. */
+const MAX_TOOL_PAGE_SIZE = 25;
+/**
+ * The content plugin's contribution to the copilot's tool catalogue — phase 1's
+ * three **read-only** tools.
+ *
+ * Bindings live with their owner: this package already holds `EntriesService`
+ * and the registry, so the tools are thin wrappers over the same services the
+ * HTTP controllers call, with no refactor and no duplicated query logic. The
+ * copilot never imports content ([`docs/design/copilot.md`](../../../../../docs/design/copilot.md) §4).
+ *
+ * **Every tool re-checks the workspace's content grants.** `WorkspaceGuard`
+ * proved the caller belongs to the workspace, but not that the workspace may
+ * reach a given type — and the type name arrives from the *model*, which is
+ * steerable by content it has read. `resolveGranted` is the one place that
+ * check lives, and every tool goes through it.
+ */
+let ContentCopilotToolProvider = class ContentCopilotToolProvider {
+    registry;
+    entries;
+    writer;
+    grants;
+    toolRegistry;
+    constructor(registry, entries, writer, grants, toolRegistry) {
+        this.registry = registry;
+        this.entries = entries;
+        this.writer = writer;
+        this.grants = grants;
+        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 three read tools, in the order the model sees them. */
+    tools() {
+        return [this.listTypes(), this.searchEntries(), this.getEntry()];
+    }
+    /**
+     * Resolves a model-supplied type name to a registered type the workspace
+     * was actually granted, or throws — the error becomes a tool error the
+     * model can recover from.
+     *
+     * "Not granted" and "does not exist" deliberately produce the **same**
+     * message: a distinguishable answer would let a run in one workspace
+     * enumerate the deployment's other content types.
+     */
+    async resolveGranted(typeName, workspaceId) {
+        const type = this.registry.get(typeName);
+        const granted = await this.grants.grantedSlugs(workspaceId);
+        if (!type || !granted.has(type.name)) {
+            throw new Error(`Unknown content type "${typeName}" in this workspace.`);
+        }
+        return type;
+    }
+    /**
+     * `admin_content_types` — the workspace's types, and a named type's full
+     * field schema on demand.
+     *
+     * This is the other half of the "summaries in the prompt, schema on
+     * demand" decision (`docs/design/copilot.md` §10): the prompt lists types
+     * without fields, and the model calls this when it needs one type's fields,
+     * costing one round trip instead of a context window.
+     */
+    listTypes() {
+        return {
+            name: 'admin_content_types',
+            title: 'Content types (admin)',
+            description: 'List the content types available in this workspace. Pass a typeName to get ' +
+                'that type’s full field schema (field names, types, required flags, relation ' +
+                'targets) AND the paths you may filter and sort on — neither is in your system ' +
+                'prompt, so call this before reasoning about a type’s fields or building a filter.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    typeName: {
+                        type: 'string',
+                        description: 'Return this one type with its full field schema. Omit to list all types.'
+                    }
+                },
+                additionalProperties: false
+            },
+            requires: [identity_server_1.PERMISSIONS.CONTENT_READ],
+            readOnly: true,
+            effect: 'read',
+            surfaces: ['copilot'],
+            handler: async (input, ctx) => {
+                const { typeName } = (input ?? {});
+                const granted = await this.grants.grantedSlugs(ctx.workspaceId);
+                if (typeName) {
+                    const type = await this.resolveGranted(typeName, ctx.workspaceId);
+                    // The filterable surface is built with `grantedTypes`, so a
+                    // relation hop into a type this workspace was never granted
+                    // is never advertised. The list query itself enforces a
+                    // wider (unpruned) schema, so advertising less is safe —
+                    // the reverse would offer paths the engine then rejects.
+                    const { schema, fields } = (0, entry_filter_surface_1.buildEntryFilterSurface)(type, {
+                        workspaceId: ctx.workspaceId,
+                        grantedTypes: granted
+                    });
+                    return {
+                        type: this.registry.serialize(type.name),
+                        // `fields` is the admin PICKER's list, which omits the
+                        // envelope timestamps a person reads off a badge —
+                        // `publishedAt` most of all, without which a model
+                        // cannot ask "published, with unpublished edits". The
+                        // root of `schema` is the SQL whitelist itself, so
+                        // unioning it advertises exactly what the engine will
+                        // accept. See `describeFilterFields`.
+                        filterableFields: (0, filter_schema_1.describeFilterFields)(fields, schema.fields)
+                    };
+                }
+                return {
+                    types: this.registry
+                        .summaries()
+                        .filter((summary) => granted.has(summary.name))
+                };
+            }
+        };
+    }
+    /** `admin_content_search` — one page of a type's entries. */
+    searchEntries() {
+        return {
+            name: 'admin_content_search',
+            title: 'Search entries (admin)',
+            description: 'Search a content type’s entries in this workspace. Combine free-text `search` ' +
+                '(across text-like fields) with a structured `filter` for precise queries, and ' +
+                '`fields` to return only the columns you need — a full entry includes rich-text ' +
+                'bodies and a page of them is very large. Results are paginated and the response ' +
+                'reports the true total, so you can state how many matched even when you have ' +
+                'only read the first page. On a localized type, pass `locale` — omitting it ' +
+                'searches the default locale, which is rarely what the user meant. ' +
+                'Publish state is two fields, so `status` alone conflates two different ' +
+                'things: entries with live content plus unpublished changes (“modified”, ' +
+                '“edited but not published”) are `status` eq "draft" AND `publishedAt` ' +
+                'op "null" value false, while never-published ones are `status` eq "draft" ' +
+                'AND `publishedAt` op "null" value true.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    typeName: {
+                        type: 'string',
+                        description: 'The content type to search, e.g. "article".'
+                    },
+                    search: {
+                        type: 'string',
+                        maxLength: 255,
+                        description: 'Free-text query. Omit to list everything.'
+                    },
+                    sort: {
+                        type: 'string',
+                        maxLength: 255,
+                        description: 'A field name, or "-" prefixed for descending, e.g. "-updatedAt".'
+                    },
+                    page: {
+                        type: 'integer',
+                        minimum: 1,
+                        description: '1-based page number.'
+                    },
+                    pageSize: {
+                        type: 'integer',
+                        minimum: 1,
+                        maximum: MAX_TOOL_PAGE_SIZE,
+                        description: `Rows per page (max ${MAX_TOOL_PAGE_SIZE}).`
+                    },
+                    filter: (0, filter_schema_1.filterTreeSchema)(),
+                    fields: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Field names to return in `values`. Strongly recommended: omitting ' +
+                            'this returns every field including rich text. The envelope ' +
+                            '(id, status, locale, timestamps) is always returned.'
+                    },
+                    locale: {
+                        type: 'string',
+                        maxLength: 35,
+                        description: 'Locale slug to search, e.g. "de". Only meaningful on a localized ' +
+                            'type; omitted, the default locale is searched.'
+                    },
+                    localeFallback: {
+                        type: 'string',
+                        enum: ['default'],
+                        description: 'Set to "default" to include the default locale where the requested ' +
+                            'one has no row.'
+                    }
+                },
+                required: ['typeName'],
+                additionalProperties: false
+            },
+            requires: [identity_server_1.PERMISSIONS.CONTENT_READ],
+            readOnly: true,
+            effect: 'read',
+            surfaces: ['copilot'],
+            handler: async (input, ctx) => {
+                const args = (input ?? {});
+                const type = await this.resolveGranted(args.typeName, ctx.workspaceId);
+                // The page size is clamped rather than trusted. The schema
+                // already caps it, but the validator is defence in depth, not
+                // the boundary — and a model that ignores `maximum` must not be
+                // able to pull the whole table into a prompt.
+                const pageSize = Math.min(Math.max(args.pageSize ?? 10, 1), Math.min(MAX_TOOL_PAGE_SIZE, entries_constants_1.MAX_PAGE_SIZE));
+                const result = await this.entries.list(type, {
+                    ...(args.search ? { search: args.search } : {}),
+                    ...(args.sort ? { sort: args.sort } : {}),
+                    // The engine's `?filter=` is a JSON string on the wire;
+                    // the model gets an object, which is far easier for it
+                    // to build correctly. `parseFilterTree` accepts either,
+                    // and validates every path against the type's schema —
+                    // a bad path is a 400 turned into a tool error, never a
+                    // query.
+                    ...(args.filter
+                        ? { filter: JSON.stringify(args.filter) }
+                        : {}),
+                    // Forwarded verbatim to the bound entry extension,
+                    // which validates the slug (unknown → error) and scopes
+                    // the rows. Content-server stays locale-agnostic.
+                    ...(args.locale ? { locale: args.locale } : {}),
+                    ...(args.localeFallback === 'default'
+                        ? { localeFallback: 'default' }
+                        : {}),
+                    page: Math.max(args.page ?? 1, 1),
+                    pageSize
+                }, ctx.workspaceId);
+                return {
+                    typeName: type.name,
+                    total: result.total,
+                    page: result.page,
+                    pageSize: result.pageSize,
+                    items: result.items.map((item) => (0, project_entry_1.projectEntry)(item, args.fields))
+                };
+            }
+        };
+    }
+    /** `admin_content_get` — one entry in full, by id. */
+    getEntry() {
+        return {
+            name: 'admin_content_get',
+            title: 'Get an entry (admin)',
+            description: 'Fetch one entry of a content type by its id, with all of its field values. ' +
+                'Use this after admin_content_search when you need an entry’s full contents.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    typeName: {
+                        type: 'string',
+                        description: 'The entry’s content type.'
+                    },
+                    id: {
+                        type: 'string',
+                        description: 'The entry’s id, as returned by admin_content_search.'
+                    },
+                    fields: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Field names to return in `values`. Omitted, every field is ' +
+                            'returned including rich text.'
+                    }
+                },
+                required: ['typeName', 'id'],
+                additionalProperties: false
+            },
+            requires: [identity_server_1.PERMISSIONS.CONTENT_READ],
+            readOnly: true,
+            effect: 'read',
+            surfaces: ['copilot'],
+            handler: async (input, ctx) => {
+                const args = (input ?? {});
+                const type = await this.resolveGranted(args.typeName, ctx.workspaceId);
+                // `getOne` is workspace-scoped and 404s a soft-deleted row, so
+                // the tool inherits both without restating either. An entry id
+                // already names one row, including its locale, so there is no
+                // `locale` parameter here — ask for a sibling by searching the
+                // type with a `localeGroupId` filter.
+                const entry = await this.writer.getOne(type, args.id, ctx.workspaceId);
+                return (0, project_entry_1.projectEntry)(entry, args.fields);
+            }
+        };
+    }
+};
+exports.ContentCopilotToolProvider = ContentCopilotToolProvider;
+exports.ContentCopilotToolProvider = ContentCopilotToolProvider = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, content_tokens_1.InjectContentRegistry)()),
+    tslib_1.__param(4, (0, common_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Function, entries_service_1.EntriesService,
+        entry_writer_service_1.EntryWriterService,
+        workspace_grants_query_1.WorkspaceGrantsQuery,
+        tools_server_1.ToolRegistry])
+], ContentCopilotToolProvider);

package/dist/lib/copilot/diff-snapshots.d.ts

@@ -0,0 +1,42 @@
+import type { SerializedContentType } from '../registry/content-type-registry';
+import type { RevisionSnapshot } from '../revisions/types/revision-view';
+/** One field that differs between two revision snapshots. */
+export interface SnapshotFieldChange {
+    /** The field's name, as the model knows it from `admin_content_types`. */
+    field: string;
+    /** The field's declared type, so a model can read the values correctly. */
+    type: string;
+    /**
+     * Whether the field's links live in a join table (an owning many-relation
+     * or any inverse). Its values are **ordered id lists**, not scalars.
+     */
+    isLinkSet: boolean;
+    /** The value in the older of the two revisions. */
+    from: unknown;
+    /** The value in the newer one. */
+    to: unknown;
+}
+/**
+ * Diffs two revision snapshots field by field, in schema order, returning
+ * **only what changed**.
+ *
+ * Returning only the changes is the point. The admin's dialog renders every
+ * field because a person scanning a table wants the unchanged rows for context;
+ * a model reasoning about "what did this edit do" gets nothing from forty
+ * `changed: false` rows except a larger prompt. The count of unchanged fields is
+ * reported separately, so the answer can still say "3 of 41 fields changed".
+ *
+ * The comparison rules mirror `content-admin`'s `diffRevision` exactly —
+ * empties collapse so `null` → `''` is not an edit, and link sets compare
+ * **order-sensitively** because the owning side's order is meaningful data. The
+ * duplication is deliberate for now: the two sides type their schema
+ * differently (`SerializedContentType` here, the admin's `ContentTypeDetail`
+ * there), so sharing this through `@orthacms/content-domain` means unifying
+ * those types first — a refactor, not a feature. If the rules ever disagree,
+ * that is the fix, not a third copy.
+ */
+export declare function diffSnapshots(type: SerializedContentType, from: RevisionSnapshot, to: RevisionSnapshot): {
+    changes: SnapshotFieldChange[];
+    unchangedFields: number;
+};
+//# sourceMappingURL=diff-snapshots.d.ts.map

package/dist/lib/copilot/diff-snapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-snapshots.d.ts","sourceRoot":"","sources":["../../../src/lib/copilot/diff-snapshots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAE/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEzE,6DAA6D;AAC7D,MAAM,WAAW,mBAAmB;IAChC,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,mDAAmD;IACnD,IAAI,EAAE,OAAO,CAAC;IACd,kCAAkC;IAClC,EAAE,EAAE,OAAO,CAAC;CACf;AA0BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CACzB,IAAI,EAAE,qBAAqB,EAC3B,IAAI,EAAE,gBAAgB,EACtB,EAAE,EAAE,gBAAgB,GACrB;IAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CAsC7D"}

package/dist/lib/copilot/diff-snapshots.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffSnapshots = diffSnapshots;
+const fields_1 = require("../types/fields");
+/** A field whose links live in a join table (owning many, or any inverse). */
+function isLinkSet(field) {
+    return (field.type === fields_1.CONTENT_FIELD_TYPE.Relation &&
+        !!field.relation &&
+        (field.relation.many || !!field.relation.inverse));
+}
+/** Treat null / undefined / empty string as one "empty", so they aren't a change. */
+function normalize(value) {
+    return value == null || value === '' ? null : value;
+}
+/** Structural equality for scalar / FK / json values, empties collapsed. */
+function sameValue(a, b) {
+    return JSON.stringify(normalize(a)) === JSON.stringify(normalize(b));
+}
+/** Order-sensitive equality for a link set — the owning side's order is data. */
+function sameLinks(a, b) {
+    return a.length === b.length && a.every((id, index) => id === b[index]);
+}
+/**
+ * Diffs two revision snapshots field by field, in schema order, returning
+ * **only what changed**.
+ *
+ * Returning only the changes is the point. The admin's dialog renders every
+ * field because a person scanning a table wants the unchanged rows for context;
+ * a model reasoning about "what did this edit do" gets nothing from forty
+ * `changed: false` rows except a larger prompt. The count of unchanged fields is
+ * reported separately, so the answer can still say "3 of 41 fields changed".
+ *
+ * The comparison rules mirror `content-admin`'s `diffRevision` exactly —
+ * empties collapse so `null` → `''` is not an edit, and link sets compare
+ * **order-sensitively** because the owning side's order is meaningful data. The
+ * duplication is deliberate for now: the two sides type their schema
+ * differently (`SerializedContentType` here, the admin's `ContentTypeDetail`
+ * there), so sharing this through `@orthacms/content-domain` means unifying
+ * those types first — a refactor, not a feature. If the rules ever disagree,
+ * that is the fix, not a third copy.
+ */
+function diffSnapshots(type, from, to) {
+    const changes = [];
+    let unchanged = 0;
+    for (const field of type.fields) {
+        if (isLinkSet(field)) {
+            const before = from.relations?.[field.name] ?? [];
+            const after = to.relations?.[field.name] ?? [];
+            if (sameLinks(before, after)) {
+                unchanged++;
+                continue;
+            }
+            changes.push({
+                field: field.name,
+                type: field.type,
+                isLinkSet: true,
+                from: before,
+                to: after
+            });
+            continue;
+        }
+        const before = from.values?.[field.name];
+        const after = to.values?.[field.name];
+        if (sameValue(before, after)) {
+            unchanged++;
+            continue;
+        }
+        changes.push({
+            field: field.name,
+            type: field.type,
+            isLinkSet: false,
+            from: before ?? null,
+            to: after ?? null
+        });
+    }
+    return { changes, unchangedFields: unchanged };
+}

package/dist/lib/copilot/entry-proposal.applier.d.ts

@@ -0,0 +1,89 @@
+import type { ProposalActor, ProposalApplier, ProposalApplyResult, ProposalTarget } from '@orthacms/copilot-domain';
+import type { ContentTypeRegistry } from '../registry/content-type-registry';
+import { EntryWriterService } from '../entries/infrastructure/persistence/entry-writer.service';
+import { WorkspaceGrantsQuery } from '../content-types/queries/workspace-grants.query';
+/**
+ * Applies `content.entry.create` — a new draft entry.
+ *
+ * **It calls `EntryWriterService.create`, the same method the POST route
+ * calls.** Not "similar to": the same. That is what makes an accepted proposal
+ * validated by `EntryValidationService`, wrapped in the workspace's shared
+ * advisory lock, snapshotted as revision 1, and passed through the bound i18n
+ * extension exactly as a hand-typed entry would be
+ * ([ADR-0005](../../../../../../docs/adr/0005-copilot-authority-model.md) §5).
+ * An applier that reimplemented the insert to "keep it simple" is the failure
+ * the port exists to prevent.
+ *
+ * The grants are re-checked here, not trusted from the proposal. The row was
+ * written when the proposal was made, and a workspace's content grants can be
+ * revoked in between — a stored `typeName` is an argument like any other.
+ */
+export declare class CreateEntryProposalApplier implements ProposalApplier {
+    private readonly registry;
+    private readonly writer;
+    private readonly grants;
+    readonly kind: "content.entry.create";
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService, grants: WorkspaceGrantsQuery);
+    apply(input: {
+        target: ProposalTarget;
+        patch: Record<string, unknown>;
+    }, actor: ProposalActor): Promise<ProposalApplyResult>;
+}
+/**
+ * Applies `content.entry.update` — a change to an existing entry's values.
+ *
+ * **Merges rather than replaces.** The admin's `PATCH` replaces the whole
+ * values bag because the editor always submits the full document; a proposal
+ * carries only the fields a reviewer approved, so replacing would silently null
+ * everything they did not see. This is the same reasoning — and the same merge
+ * semantics — as the public API's partial update.
+ *
+ * The merge reads the entry **now**, not when the proposal was made, so a
+ * proposal accepted an hour later writes the approved fields onto whatever the
+ * entry has become instead of resurrecting a stale document. A reviewer
+ * approving "fix this typo" gets that typo fixed, not the rest of the entry
+ * rewound.
+ */
+export declare class UpdateEntryProposalApplier implements ProposalApplier {
+    private readonly registry;
+    private readonly writer;
+    private readonly grants;
+    readonly kind: "content.entry.update";
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService, grants: WorkspaceGrantsQuery);
+    apply(input: {
+        target: ProposalTarget;
+        patch: Record<string, unknown>;
+    }, actor: ProposalActor): Promise<ProposalApplyResult>;
+}
+/**
+ * Applies `content.entry.bulk-save` — a batch of creates and edits, carried out
+ * as one change.
+ *
+ * **Item by item through the same `EntryWriterService` methods the other two
+ * appliers call**, for the same reason they do: validation, the advisory lock,
+ * the revision snapshot and the i18n sibling sync all have to happen per entry,
+ * and a batch-shaped shortcut around any of them would be a second write path.
+ * Sequentially, not concurrently — each write takes the workspace's shared
+ * content lock, so a fan-out would mostly contend with itself.
+ *
+ * **It stops at the first failure and throws.** There is no per-item verdict to
+ * show: a proposal is one row with one status, and its card says "Saved" or
+ * "Not saved". Carrying on after a failure would grow the number of entries
+ * written under a receipt that then reports failure — so the batch halts, and
+ * the error names exactly how many landed, which is what the model reads back
+ * to the user. (The public API's `bulkSave` does the opposite and keeps going,
+ * because there the caller gets every item's verdict and can retry the ones it
+ * can fix.)
+ */
+export declare class BulkSaveEntriesProposalApplier implements ProposalApplier {
+    private readonly registry;
+    private readonly writer;
+    private readonly grants;
+    readonly kind: "content.entry.bulk-save";
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService, grants: WorkspaceGrantsQuery);
+    apply(input: {
+        target: ProposalTarget;
+        patch: Record<string, unknown>;
+    }, actor: ProposalActor): Promise<ProposalApplyResult>;
+}
+//# sourceMappingURL=entry-proposal.applier.d.ts.map

package/dist/lib/copilot/entry-proposal.applier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-proposal.applier.d.ts","sourceRoot":"","sources":["../../../src/lib/copilot/entry-proposal.applier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACR,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,cAAc,EACjB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4DAA4D,CAAC;AAChG,OAAO,EAAE,oBAAoB,EAAE,MAAM,iDAAiD,CAAC;AA8CvF;;;;;;;;;;;;;;;GAeG;AACH,qBACa,0BAA2B,YAAW,eAAe;IAK1D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAN3B,QAAQ,CAAC,IAAI,yBAAsC;gBAI9B,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,oBAAoB;IAG3C,KAAK,CACP,KAAK,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EACjE,KAAK,EAAE,aAAa,GACrB,OAAO,CAAC,mBAAmB,CAAC;CAiClC;AAED;;;;;;;;;;;;;;GAcG;AACH,qBACa,0BAA2B,YAAW,eAAe;IAK1D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAN3B,QAAQ,CAAC,IAAI,yBAAsC;gBAI9B,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,oBAAoB;IAG3C,KAAK,CACP,KAAK,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EACjE,KAAK,EAAE,aAAa,GACrB,OAAO,CAAC,mBAAmB,CAAC;CAwClC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBACa,8BAA+B,YAAW,eAAe;IAK9D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAN3B,QAAQ,CAAC,IAAI,4BAA0C;gBAIlC,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,oBAAoB;IAG3C,KAAK,CACP,KAAK,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EACjE,KAAK,EAAE,aAAa,GACrB,OAAO,CAAC,mBAAmB,CAAC;CAqFlC"}