@manta-eu/react 0.1.0 → 0.1.2

package/dist/routes/rules/components/CreateRuleChatModal.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { ChatContextKind } from "@manta-eu/client/shared/agent-types";
+import { generateRuleDraftIri } from "@manta-eu/client/shared/chat-context";
+import { parseError } from "@manta-eu/client/shared/error-utils";
+import { createUserMessage } from "@manta-eu/client/shared/message-utils";
+import { isPresent } from "@manta-eu/lib/present";
+import { ArrowRight, FileCode2 } from "lucide-react";
+import { useId } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { Button } from "#components/button/index";
+import { Dialog, DialogBody, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "#components/modal/index";
+import { Textarea } from "#components/textarea/Textarea";
+import { useChatManagerConnection } from "#providers/ChatManagerProvider";
+import { useChatPanel } from "#providers/ChatPanelContext";
+const createRuleChatFormSchema = z.object({
+    intent: z.string().trim().min(1, "Describe the rule you want"),
+});
+export function CreateRuleChatModal(props) {
+    const { open, onOpenChange, onStartFromBlankRule, model, ruleSuggestions } = props;
+    const { startContextConversation } = useChatManagerConnection();
+    const { open: openChat } = useChatPanel();
+    const formId = useId();
+    const form = useForm({
+        resolver: zodResolver(createRuleChatFormSchema),
+        defaultValues: { intent: "" },
+        mode: "onChange",
+    });
+    async function handleDraft(values) {
+        try {
+            const conversation = await startContextConversation({ kind: ChatContextKind.RuleCreate, draftIri: generateRuleDraftIri() }, createUserMessage({ text: values.intent, model }));
+            if (!conversation)
+                return;
+            openChat();
+            form.reset();
+            onOpenChange(false);
+        }
+        catch (err) {
+            const errorInfo = parseError(err, "Couldn't start drafting the rule");
+            toast.error(errorInfo.message, { description: errorInfo.description });
+        }
+    }
+    return (_jsx(Dialog, { open: open, onOpenChange: onOpenChange, children: _jsxs(DialogContent, { className: "max-w-2xl", onPointerDownOutside: (event) => {
+                if (form.formState.isDirty)
+                    event.preventDefault();
+            }, onEscapeKeyDown: (event) => {
+                if (form.formState.isDirty)
+                    event.preventDefault();
+            }, children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { text: "Create a rule" }), _jsx(DialogDescription, { children: "Describe it in your words \u2014 Manta drafts the rule for your review." })] }), _jsxs(DialogBody, { className: "space-y-4", children: [_jsxs("form", { id: formId, onSubmit: form.handleSubmit(handleDraft), children: [_jsx(Textarea, { placeholder: "e.g. Pause underperforming ads when their CTR stays below the account average for a week\u2026", className: "min-h-32 border rounded border-default-border bg-base-background", autoFocus: true, ...form.register("intent") }), form.formState.errors.intent && (_jsx("div", { className: "typography-small text-error-foreground mt-2", role: "alert", children: form.formState.errors.intent.message }))] }), isPresent(ruleSuggestions) && (_jsx("div", { className: "flex flex-col gap-1", children: ruleSuggestions.map((suggestion, index) => (_jsx("button", { type: "button", onClick: () => form.setValue("intent", suggestion, { shouldValidate: true, shouldDirty: true }), className: "flex w-full cursor-pointer items-center gap-3 rounded-md-v4 px-3 py-2.5 text-left transition-colors hover:bg-muted", title: suggestion, children: _jsx("span", { className: "typography-small text-default-foreground", children: suggestion }) }, `${suggestion}-${index}`))) }))] }), _jsxs(DialogFooter, { children: [_jsx(Button, { type: "button", variant: "secondary", icon: FileCode2, className: "mr-auto", onClick: onStartFromBlankRule, children: "Start from blank rule" }), _jsx(Button, { type: "button", variant: "ghost", disabled: !form.formState.isDirty, onClick: () => form.reset(), children: "Clear" }), _jsx(Button, { type: "submit", form: formId, icon: ArrowRight, disabled: !form.formState.isValid || form.formState.isSubmitting, children: form.formState.isSubmitting ? "Starting…" : "Draft rule" })] })] }) }));
+}

package/dist/routes/rules/components/RuleActionabilityBadge.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps } from "react";
+import type { RuleActionabilityAnalysis } from "./rule-actionability.js";
+type RuleActionabilityBadgeProps = ComponentProps<"span"> & {
+    analysis?: RuleActionabilityAnalysis;
+};
+export declare function RuleActionabilityBadge(props: RuleActionabilityBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=RuleActionabilityBadge.d.ts.map

package/dist/routes/rules/components/RuleActionabilityBadge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleActionabilityBadge.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleActionabilityBadge.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAGtE,KAAK,2BAA2B,GAAG,cAAc,CAAC,MAAM,CAAC,GAAG;IAC1D,QAAQ,CAAC,EAAE,yBAAyB,CAAC;CACtC,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,kDAuBxE"}

package/dist/routes/rules/components/RuleActionabilityBadge.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { compactUri } from "@manta-eu/client/shared/rdf-namespaces";
+import { humanList } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { SparklesIcon } from "lucide-react";
+import { InlineMeta } from "./InlineMeta.js";
+import { Tooltip, TooltipContent, TooltipTrigger } from "#components/tooltip/index";
+export function RuleActionabilityBadge(props) {
+    const { analysis, className, ...restProps } = props;
+    if (!analysis?.isAutomaticallyActionable) {
+        return null;
+    }
+    const supportedShapes = analysis.supportedActionShapeIris.map(compactUri);
+    const title = analysis.hasSupportedActionShape && isPresent(supportedShapes)
+        ? `Outputs supported action shape: ${humanList(supportedShapes)}`
+        : "Automatically applied by the knowledge graph when the inputs change";
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx(InlineMeta, { icon: _jsx(SparklesIcon, { className: "size-3.5" }), className: className, ...restProps, children: "Automatic" }) }), _jsx(TooltipContent, { className: "max-w-xs typography-small", children: title })] }));
+}

package/dist/routes/rules/components/RuleAffectedActionPlansSection.d.ts

@@ -0,0 +1,6 @@
+type RuleAffectedActionPlansSectionProps = {
+    graphs: readonly string[];
+};
+export declare function RuleAffectedActionPlansSection(props: RuleAffectedActionPlansSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RuleAffectedActionPlansSection.d.ts.map

package/dist/routes/rules/components/RuleAffectedActionPlansSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleAffectedActionPlansSection.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleAffectedActionPlansSection.tsx"],"names":[],"mappings":"AAqCA,KAAK,mCAAmC,GAAG;IACzC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B,CAAC;AAeF,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,mCAAmC,2CA2OxF"}

package/dist/routes/rules/components/RuleAffectedActionPlansSection.js

@@ -0,0 +1,151 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { buildPlanHref, extractPlanName } from "@manta-eu/client/shared/agent-mode";
+import { compactUri } from "@manta-eu/client/shared/rdf-namespaces";
+import { formatDateTime } from "@manta-eu/lib/date";
+import { humanCount, humanList } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { useReactTable } from "@tanstack/react-table";
+import { ArrowRight, ChevronDown, Layers } from "lucide-react";
+import { useMemo, useState } from "react";
+import { Link } from "react-router";
+import { InlineMeta } from "./InlineMeta.js";
+import { Badge } from "#components/badge/index";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "#components/collapsible/index";
+import { PaginationBlock } from "#components/pagination/index";
+import { formatIntegration, IntegrationIcon, planStateVariant, statusLabel, } from "#components/planning/plan-detail-utils";
+import { Skeleton } from "#components/skeleton/index";
+import { createTableConfig, DataTable } from "#components/table/index";
+import { useActionPlans } from "#hooks/useActionPlans";
+import { cn } from "#lib/utils";
+import { useMantaClient } from "#providers/index";
+const pageSize = 10;
+function actionsLabel(plan) {
+    return plan.completedActionCount > 0 ? `${plan.completedActionCount} / ${plan.actionCount}` : `${plan.actionCount}`;
+}
+function actionsBreakdown(plan) {
+    if (!isPresent(plan.actionCountByType))
+        return undefined;
+    return humanList(plan.actionCountByType.map(({ typeName, count }) => `${count} ${typeName}`));
+}
+function planRowName(row) {
+    return extractPlanName(row.graph) || compactUri(row.graph);
+}
+function MissingValue() {
+    return _jsx("span", { className: "text-muted-foreground", children: "\u2014" });
+}
+export function RuleAffectedActionPlansSection(props) {
+    const { graphs } = props;
+    const [open, setOpen] = useState(false);
+    const [page, setPage] = useState(0);
+    const { mantaClient } = useMantaClient();
+    const planCount = graphs.length;
+    const planCountLabel = humanCount(planCount, "plan");
+    const hasPlans = planCount > 0;
+    const totalPages = Math.max(1, Math.ceil(planCount / pageSize));
+    const safePage = Math.min(page, totalPages - 1);
+    const pageGraphs = useMemo(() => graphs.slice(safePage * pageSize, safePage * pageSize + pageSize), [graphs, safePage]);
+    const { plans, isLoading, isPlaceholderData, error } = useActionPlans(mantaClient, { graphIris: pageGraphs, availability: "ALL", limit: pageSize }, { enabled: open && hasPlans, refetchInterval: false });
+    const rows = useMemo(() => pageGraphs.map((graph) => ({
+        graph,
+        plan: plans.find((candidate) => candidate.iri === graph),
+    })), [pageGraphs, plans]);
+    const columns = useMemo(() => [
+        {
+            id: "plan",
+            accessorFn: planRowName,
+            enableSorting: false,
+            header: "Plan",
+            cell: ({ row }) => {
+                const { graph, plan } = row.original;
+                const name = planRowName(row.original);
+                const href = buildPlanHref(graph);
+                if (!plan) {
+                    return _jsx("span", { title: graph, children: compactUri(graph) });
+                }
+                return (_jsxs("div", { className: "flex min-w-0 flex-col gap-1 text-left", children: [_jsxs("div", { className: "flex min-w-0 items-center gap-2", children: [_jsx(Link, { to: href, className: "min-w-0 truncate hover:text-primary", title: graph, children: name }), !plan.hasCurrentFacts && (_jsx(Badge, { variant: "copy", size: "sm", className: "shrink-0", children: "History only" }))] }), plan.description && _jsx("span", { className: "truncate text-muted-foreground", children: plan.description })] }));
+            },
+        },
+        {
+            id: "status",
+            accessorFn: (row) => row.plan?.state ?? "",
+            enableSorting: false,
+            header: "Status",
+            cell: ({ row }) => {
+                const { plan } = row.original;
+                if (!plan)
+                    return _jsx(MissingValue, {});
+                return (_jsx(Badge, { variant: planStateVariant(plan.state), size: "sm", children: statusLabel(plan.state) }));
+            },
+        },
+        {
+            id: "channel",
+            accessorFn: (row) => row.plan?.primaryIntegration ?? "",
+            enableSorting: false,
+            header: "Channel",
+            cell: ({ row }) => {
+                const { plan } = row.original;
+                if (!plan?.primaryIntegration)
+                    return _jsx(MissingValue, {});
+                return (_jsx(InlineMeta, { icon: _jsx(IntegrationIcon, { integration: plan.primaryIntegration }), children: formatIntegration(plan.primaryIntegration) }));
+            },
+        },
+        {
+            id: "actions",
+            accessorFn: (row) => row.plan?.actionCount ?? -1,
+            enableSorting: false,
+            header: "Actions",
+            meta: { type: "number" },
+            cell: ({ row }) => {
+                const { plan } = row.original;
+                return plan ? _jsx("span", { title: actionsBreakdown(plan), children: actionsLabel(plan) }) : _jsx(MissingValue, {});
+            },
+        },
+        {
+            id: "lastRun",
+            accessorFn: (row) => row.plan?.lastRunAt ?? "",
+            enableSorting: false,
+            header: "Last run",
+            cell: ({ row }) => {
+                const { plan } = row.original;
+                return plan?.lastRunAt ? _jsx("span", { children: formatDateTime(plan.lastRunAt) }) : _jsx(MissingValue, {});
+            },
+        },
+        {
+            id: "updated",
+            accessorFn: (row) => row.plan?.updatedAt ?? "",
+            enableSorting: false,
+            header: "Updated",
+            cell: ({ row }) => {
+                const { plan } = row.original;
+                return plan?.updatedAt ? _jsx("span", { children: formatDateTime(plan.updatedAt) }) : _jsx(MissingValue, {});
+            },
+        },
+        {
+            id: "open",
+            enableSorting: false,
+            cell: ({ row }) => {
+                const { graph, plan } = row.original;
+                if (!plan)
+                    return null;
+                const name = planRowName(row.original);
+                const href = buildPlanHref(graph);
+                return (_jsx(Link, { to: href, "aria-label": `Open ${name}`, className: "inline-flex hover:text-primary", children: _jsx(ArrowRight, { className: "size-4" }) }));
+            },
+        },
+    ], []);
+    const table = useReactTable(createTableConfig({
+        data: rows,
+        columns,
+        pagination: { pageIndex: 0, pageSize },
+    }));
+    function renderBody() {
+        if (error) {
+            return (_jsx("div", { className: "border-t border-muted-border px-4 py-6 typography-small text-error-foreground", children: error }));
+        }
+        if (isLoading) {
+            return (_jsx("div", { className: "border-t border-muted-border", children: Array.from({ length: 3 }, (_, rowIndex) => (_jsxs("div", { className: "flex items-center gap-4 border-b border-muted-border px-4 py-3 last:border-b-0", children: [_jsx(Skeleton, { className: "h-4 w-40 rounded-md" }), _jsx(Skeleton, { className: "h-5 w-16 rounded-full" }), _jsx(Skeleton, { className: "h-4 w-24 rounded-md" }), _jsx(Skeleton, { className: "h-4 w-12 rounded-md" }), _jsx(Skeleton, { className: "h-4 w-20 rounded-md" })] }, `rule-affected-plans-skeleton-${rowIndex}`))) }));
+        }
+        return (_jsxs(_Fragment, { children: [_jsx(DataTable, { table: table, isRefetching: isPlaceholderData, className: "border-t border-muted-border" }), totalPages > 1 && (_jsx("div", { className: "flex justify-end border-t border-muted-border px-4 py-2", children: _jsx(PaginationBlock, { currentPageIndex: safePage, totalPages: totalPages, onPageChange: setPage, totalCount: planCount }) }))] }));
+    }
+    return (_jsx(Collapsible, { open: hasPlans && open, onOpenChange: setOpen, children: _jsxs("section", { className: "overflow-hidden rounded-xl border border-muted-border bg-card", children: [_jsx(CollapsibleTrigger, { asChild: true, children: _jsxs("button", { type: "button", disabled: !hasPlans, className: "flex w-full flex-wrap items-center gap-x-2 gap-y-1 px-4 py-3 text-left transition-colors enabled:cursor-pointer enabled:hover:bg-faint disabled:cursor-default", children: [_jsx(Layers, { className: "size-4 shrink-0 text-muted-foreground" }), _jsx("h2", { className: "typography-small-medium text-default-foreground", children: "Affected action plans" }), _jsxs("span", { className: "typography-caption text-muted-foreground", children: [planCountLabel, " ", planCount === 1 ? "uses" : "use", " this rule"] }), _jsxs("span", { className: "ml-auto flex shrink-0 items-center gap-2", children: [hasPlans && (_jsx(Badge, { variant: "secondary", size: "sm", children: planCountLabel })), _jsx(ChevronDown, { className: cn("size-4 text-muted-foreground transition-transform", open ? "rotate-180" : "rotate-0", !hasPlans && "opacity-0") })] })] }) }), _jsx(CollapsibleContent, { children: renderBody() })] }) }));
+}

package/dist/routes/rules/components/RuleAst.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentProps } from "react";
+export type RuleAstProps = ComponentProps<"div"> & {
+    rule: string;
+};
+export declare const RuleAst: import("react").ForwardRefExoticComponent<Omit<RuleAstProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=RuleAst.d.ts.map

package/dist/routes/rules/components/RuleAst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleAst.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleAst.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAK5C,MAAM,MAAM,YAAY,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IACjD,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,OAAO,sHAgClB,CAAC"}

package/dist/routes/rules/components/RuleAst.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { forwardRef, useMemo } from "react";
+import { DatalogAst, parseDatalogRuleCached } from "#ldo-ui";
+import { cn } from "#lib/utils";
+export const RuleAst = forwardRef(function RuleAst(props, ref) {
+    const { rule, className, ...restProps } = props;
+    const isEmpty = !isPresent(rule);
+    const { ast, error } = useMemo(() => {
+        if (isEmpty)
+            return { ast: null, error: null };
+        return parseDatalogRuleCached(rule);
+    }, [rule, isEmpty]);
+    if (isEmpty) {
+        return (_jsx("div", { ref: ref, className: cn("typography-small text-muted-foreground", className), ...restProps, children: "No rule to display" }));
+    }
+    if (error) {
+        return (_jsx("div", { ref: ref, className: cn("bg-error", className), ...restProps, children: _jsxs("p", { className: "typography-small text-error-foreground", children: ["Parse error: ", error] }) }));
+    }
+    if (!ast)
+        return null;
+    return (_jsx("div", { ref: ref, className: cn(className), ...restProps, children: _jsx(DatalogAst, { rule: rule }) }));
+});

package/dist/routes/rules/components/RuleDependentRulesSection.d.ts

@@ -0,0 +1,6 @@
+type RuleDependentRulesSectionProps = {
+    dependentRuleIris: readonly string[];
+};
+export declare function RuleDependentRulesSection(props: RuleDependentRulesSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RuleDependentRulesSection.d.ts.map

package/dist/routes/rules/components/RuleDependentRulesSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleDependentRulesSection.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleDependentRulesSection.tsx"],"names":[],"mappings":"AAQA,KAAK,8BAA8B,GAAG;IACpC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,8BAA8B,2CA2C9E"}

package/dist/routes/rules/components/RuleDependentRulesSection.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { compactUri } from "@manta-eu/client/shared/rdf-namespaces";
+import { humanCount } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { ArrowRight, GitBranch } from "lucide-react";
+import { Link } from "react-router";
+import { getRuleDisplayName, getRuleHref } from "./rules.utils.js";
+import { Badge } from "#components/badge/index";
+export function RuleDependentRulesSection(props) {
+    const { dependentRuleIris } = props;
+    return (_jsxs("section", { className: "overflow-hidden rounded-xl border border-muted-border bg-card", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-2 border-b border-muted-border px-4 py-3", children: [_jsx(GitBranch, { className: "size-4 shrink-0 text-muted-foreground" }), _jsx("h2", { className: "typography-small-medium text-default-foreground", children: "Dependent rules" }), _jsx(Badge, { variant: "secondary", size: "sm", className: "ml-auto", children: humanCount(dependentRuleIris.length, "rule") })] }), !isPresent(dependentRuleIris) ? (_jsx("p", { className: "px-4 py-5 typography-small text-muted-foreground", children: "No other rules build on this rule. It is a top-level rule." })) : (_jsx("div", { className: "max-h-80 overflow-y-auto", children: dependentRuleIris.map((ruleIri) => {
+                    const label = getRuleDisplayName(ruleIri);
+                    const href = getRuleHref({ ruleIri });
+                    return (_jsxs(Link, { to: href, className: "flex items-center gap-3 border-b border-muted-border px-4 py-3 transition-colors last:border-b-0 hover:bg-faint", children: [_jsxs("span", { className: "flex min-w-0 flex-1 flex-col gap-0.5", children: [_jsx("span", { className: "truncate typography-small-medium text-default-foreground", children: label }), _jsx("span", { className: "truncate font-mono typography-tiny text-muted-foreground", title: ruleIri, children: compactUri(ruleIri) })] }), _jsx(ArrowRight, { className: "size-4 shrink-0 text-muted-foreground", "aria-hidden": "true" })] }, ruleIri));
+                }) }))] }));
+}

package/dist/routes/rules/components/RuleDetailsPage.d.ts

@@ -0,0 +1,14 @@
+import type { GQLRule } from "@manta-eu/client";
+import { type SupportedActionShapeRef } from "./rule-actionability.js";
+import { type RuleHandlers } from "./rules.utils.js";
+export type RuleDetailsPageProps = Pick<RuleHandlers, "onEditRule"> & {
+    rule: GQLRule | null;
+    allRules?: readonly GQLRule[];
+    supportedActionShapes?: readonly SupportedActionShapeRef[];
+    isActionShapesLoading?: boolean;
+    ownerNameByUserId?: ReadonlyMap<string, string>;
+    isLoading?: boolean;
+    error?: string | null;
+};
+export declare function RuleDetailsPage(props: RuleDetailsPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RuleDetailsPage.d.ts.map

package/dist/routes/rules/components/RuleDetailsPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleDetailsPage.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleDetailsPage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAOhD,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAO9F,OAAO,EAML,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAYvB,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,GAAG;IACpE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IACrB,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC9B,qBAAqB,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC3D,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CAgJ1D"}

package/dist/routes/rules/components/RuleDetailsPage.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { compactUri } from "@manta-eu/client/shared/rdf-namespaces";
+import { humanCount } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { FileCode2, Layers } from "lucide-react";
+import { useMemo } from "react";
+import { InlineMeta } from "./InlineMeta.js";
+import { analyzeRuleActionability } from "./rule-actionability.js";
+import { buildRuleProducerIndex, lookupRuleProducers } from "./rule-producers.js";
+import { RuleActionabilityBadge } from "./RuleActionabilityBadge.js";
+import { RuleAffectedActionPlansSection } from "./RuleAffectedActionPlansSection.js";
+import { RuleDependentRulesSection } from "./RuleDependentRulesSection.js";
+import { RuleOwnershipBadge } from "./RuleOwnershipBadge.js";
+import { RuleProducersSection } from "./RuleProducersSection.js";
+import { getRuleDisplayName, getRuleDisplayText, getExternalDependentRuleIris, getRuleOwnerName, getRuleStatus, } from "./rules.utils.js";
+import { RuleSampleFactsSection } from "./RuleSampleFactsSection.js";
+import { RuleSetup } from "./RuleSetup.js";
+import { RuleStatusBadge } from "./RuleStatusBadge.js";
+import { Banner } from "#components/banner/index";
+import { EmptyState } from "#components/empty-state/index";
+import { PageBody } from "#components/layouts/page/index";
+import { Loader } from "#components/loader/index";
+import { RunHistoryTable } from "#components/planning/RunHistoryTable";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "#components/tabs/index";
+export function RuleDetailsPage(props) {
+    const { rule, allRules, supportedActionShapes, isActionShapesLoading = false, ownerNameByUserId, isLoading = false, error, onEditRule, } = props;
+    const actionability = useMemo(() => {
+        return rule
+            ? analyzeRuleActionability(getRuleDisplayText(rule), supportedActionShapes ?? [], rule.namedGraphs)
+            : undefined;
+    }, [rule, supportedActionShapes]);
+    const renderTermProducers = useMemo(() => {
+        if (!allRules || !rule)
+            return undefined;
+        const producerIndex = buildRuleProducerIndex(allRules, rule.ruleIri);
+        return (term, graph) => {
+            const producers = lookupRuleProducers(producerIndex, term, graph);
+            return isPresent(producers) ? _jsx(RuleProducersSection, { producers: producers }) : null;
+        };
+    }, [allRules, rule]);
+    const ownerName = rule ? getRuleOwnerName(rule, ownerNameByUserId) : null;
+    const status = rule ? getRuleStatus(rule) : null;
+    const planGraphs = rule?.namedGraphs ?? [];
+    const planCount = planGraphs.length;
+    const hasPlans = isPresent(planGraphs);
+    const ruleDisplayName = rule ? getRuleDisplayName(rule.ruleIri) : "";
+    const displayRuleText = rule ? getRuleDisplayText(rule) : "";
+    const dependentRuleIris = rule ? getExternalDependentRuleIris(rule) : [];
+    return (_jsx(PageBody, { children: _jsxs("div", { className: "mx-auto flex w-full max-w-6xl flex-col gap-4", children: [error && _jsx(Banner, { label: error }), isLoading ? (_jsx("div", { className: "flex min-h-64 items-center justify-center", children: _jsx(Loader, { className: "size-8" }) })) : rule ? (_jsxs(_Fragment, { children: [_jsxs("section", { className: "flex min-w-0 gap-4 px-1 py-2", children: [_jsx("div", { className: "flex size-11 shrink-0 items-center justify-center rounded-lg bg-faint text-muted-foreground", children: _jsx(FileCode2, { className: "size-5" }) }), _jsxs("div", { className: "min-w-0 flex-1 space-y-3", children: [_jsx("h2", { className: "truncate typography-large-body-semibold", title: compactUri(rule.ruleIri), children: ruleDisplayName }), _jsxs("div", { className: "flex flex-wrap items-center gap-x-4 gap-y-2", children: [status && _jsx(RuleStatusBadge, { status: status, appearance: "inline" }), !isActionShapesLoading &&
+                                                    (actionability?.isAutomaticallyActionable ? (_jsx(RuleActionabilityBadge, { analysis: actionability })) : (_jsx(InlineMeta, { icon: _jsx(FileCode2, { className: "size-3.5" }), children: "Manual" }))), _jsx(RuleOwnershipBadge, { ownership: rule.ownedBy ?? null, ownerName: ownerName, appearance: "inline" }), _jsx(InlineMeta, { icon: _jsx(Layers, { className: "size-3.5" }), children: humanCount(planCount, "plan") })] }), isPresent(rule.mentionedTypes) && (_jsx("div", { className: "flex flex-wrap items-center gap-x-3 gap-y-1", children: rule.mentionedTypes.map((type) => (_jsx("span", { className: "font-mono typography-caption text-muted-foreground", title: type, children: compactUri(type) }, type))) }))] })] }), _jsxs(Tabs, { defaultValue: "overview", className: "gap-4", children: [_jsxs(TabsList, { children: [_jsx(TabsTrigger, { value: "overview", children: "Overview" }), _jsx(TabsTrigger, { value: "history", children: "Run history" })] }), _jsxs(TabsContent, { value: "overview", forceMount: true, className: "flex flex-col gap-4 data-[state=inactive]:hidden", children: [_jsxs("section", { className: "flex flex-col gap-3 rounded-xl border border-muted-border bg-card p-5", children: [_jsx("h2", { className: "typography-small-medium text-default-foreground", children: "Rule setup" }), _jsx(RuleSetup, { ruleText: displayRuleText, onStageChange: onEditRule ? (newRuleText) => onEditRule(rule.ruleIri, newRuleText) : undefined, renderTermProducers: renderTermProducers }), rule.isModified && rule.committedRule && (_jsxs("details", { className: "rounded-lg border border-warning/20 bg-warning/5 p-3", children: [_jsx("summary", { className: "cursor-pointer typography-small text-warning-foreground", children: "View original committed version" }), _jsx("div", { className: "mt-3", children: _jsx(RuleSetup, { ruleText: rule.committedRule, renderTermProducers: renderTermProducers }) })] }))] }), _jsx(RuleAffectedActionPlansSection, { graphs: planGraphs }, rule.ruleIri), _jsx(RuleDependentRulesSection, { dependentRuleIris: dependentRuleIris }), _jsx(RuleSampleFactsSection, { rule: rule })] }), _jsx(TabsContent, { value: "history", className: "flex flex-col gap-3", children: hasPlans ? (_jsxs(_Fragment, { children: [_jsx("p", { className: "typography-caption text-muted-foreground", children: "Rules are not executed on their own \u2014 they derive data continuously as soon as it changes. This list shows runs of the action plans this rule contributes to." }), _jsx(RunHistoryTable, { planIris: planGraphs, showPlanColumn: true, emptyDescription: "None of this rule's action plans have been executed yet. Runs will appear here once one does." }, rule.ruleIri)] })) : (_jsx(EmptyState, { icon: Layers, title: "No action plans", description: "This rule does not contribute to an action plan, so there is no run history to show." })) })] })] })) : (_jsx(EmptyState, { icon: FileCode2, title: "Rule not found", description: "The selected rule is not available." }))] }) }));
+}

package/dist/routes/rules/components/RuleProducersSection.d.ts

@@ -0,0 +1,7 @@
+import type { RuleProducer } from "./rule-producers.js";
+type RuleProducersSectionProps = {
+    producers: readonly RuleProducer[];
+};
+export declare function RuleProducersSection(props: RuleProducersSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RuleProducersSection.d.ts.map

package/dist/routes/rules/components/RuleProducersSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleProducersSection.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleProducersSection.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIrD,KAAK,yBAAyB,GAAG;IAC/B,SAAS,EAAE,SAAS,YAAY,EAAE,CAAC;CACpC,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,2CAyBpE"}

package/dist/routes/rules/components/RuleProducersSection.js

@@ -0,0 +1,10 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { humanPlural } from "@manta-eu/lib/humanize";
+import { ArrowRight } from "lucide-react";
+import { Link } from "react-router";
+import { getRuleDisplayName, getRuleHref } from "./rules.utils.js";
+import { Badge } from "#components/badge/index";
+export function RuleProducersSection(props) {
+    const { producers } = props;
+    return (_jsxs("div", { className: "mt-1.5 border-t border-muted-foreground/30 pt-1.5", children: [_jsxs("p", { className: "typography-tiny text-muted-foreground", children: ["Derived by ", humanPlural("rule", producers.length)] }), _jsx("div", { className: "mt-0.5 flex max-h-40 flex-col overflow-y-auto", children: producers.map((producer) => (_jsxs(Link, { to: getRuleHref(producer), className: "group flex items-center gap-1.5 py-0.5 typography-small-medium hover:underline", children: [_jsx("span", { className: "min-w-0 truncate", children: getRuleDisplayName(producer.ruleIri) }), producer.isStaged && (_jsx(Badge, { variant: "warning", size: "sm", children: "Staged" })), _jsx(ArrowRight, { className: "size-3.5 shrink-0 opacity-60 group-hover:opacity-100", "aria-hidden": "true" })] }, producer.ruleIri))) })] }));
+}

package/dist/routes/rules/components/RuleSampleFactsSection.d.ts

@@ -0,0 +1,7 @@
+import type { GQLRule } from "@manta-eu/client";
+type RuleSampleFactsSectionProps = {
+    rule: GQLRule;
+};
+export declare function RuleSampleFactsSection(props: RuleSampleFactsSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RuleSampleFactsSection.d.ts.map

package/dist/routes/rules/components/RuleSampleFactsSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleSampleFactsSection.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleSampleFactsSection.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAwBhD,KAAK,2BAA2B,GAAG;IACjC,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAUF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,2CAmDxE"}

package/dist/routes/rules/components/RuleSampleFactsSection.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { humanizeEntityName } from "@manta-eu/client/shared/agent-mode";
+import { iriLocalName } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { ExternalLink, FlaskConical } from "lucide-react";
+import { useMemo } from "react";
+import { Link } from "react-router";
+import { getRuleDisplayText } from "./rules.utils.js";
+import { buildSampleFactsQuery } from "./sample-facts-query.js";
+import { Banner } from "#components/banner/index";
+import { Button } from "#components/button/index";
+import { Skeleton } from "#components/skeleton/index";
+import { bindingLiteralDatatype, bindingValue, buildExplainPath, MaskedValue, maskText, ontologyTermIri, OntologyTermText, usePersonalDataResolutionFor, useSparqlSelect, } from "#ldo-ui";
+export function RuleSampleFactsSection(props) {
+    const { rule } = props;
+    const queryState = useMemo(() => {
+        try {
+            return { query: buildSampleFactsQuery(getRuleDisplayText(rule)), error: null };
+        }
+        catch (error) {
+            return { query: "", error: error instanceof Error ? error.message : "Failed to build sample fact query" };
+        }
+    }, [rule]);
+    const queryResult = useSparqlSelect({
+        query: queryState.query,
+        queryKey: ["rule-sample-facts", rule.ruleIri, queryState.query],
+        enabled: !!queryState.query,
+    });
+    const samples = useMemo(() => (queryResult.data ?? [])
+        .map((binding) => {
+        const subject = bindingValue(binding, "S");
+        const predicate = bindingValue(binding, "P");
+        const object = bindingValue(binding, "O");
+        const graph = bindingValue(binding, "G");
+        const objectDatatype = bindingLiteralDatatype(binding, "O");
+        if (!subject || !predicate || !object)
+            return null;
+        return { subject, predicate, object, graph, objectDatatype };
+    })
+        .filter((sample) => sample !== null), [queryResult.data]);
+    if (queryState.error) {
+        return (_jsx(Banner, { type: "error", label: "Could not build sample facts query", description: queryState.error, size: "loose" }));
+    }
+    return (_jsxs("section", { className: "flex flex-col gap-3 rounded-xl border border-muted-border bg-card p-4", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(FlaskConical, { className: "size-4 text-muted-foreground" }), _jsx("h2", { className: "typography-small-medium text-default-foreground", children: "Sample inferred facts" })] }), _jsx(RuleSampleFactsBody, { isLoading: queryResult.isLoading, error: queryResult.error, samples: samples })] }));
+}
+function RuleSampleFactsBody(props) {
+    const { isLoading, error, samples } = props;
+    const personalDataResolutions = usePersonalDataResolutionFor(samples.map((sample) => sample.predicate));
+    if (isLoading) {
+        return (_jsx("div", { className: "overflow-hidden rounded-md border border-muted-border bg-card/70", children: Array.from({ length: 3 }, (_, index) => (_jsxs("div", { className: "flex w-full items-center gap-3 border-b border-muted-border px-3 py-2 last:border-b-0", children: [_jsx(Skeleton, { className: "h-4 flex-1 rounded-md" }), _jsx(Skeleton, { className: "h-6 w-24 rounded-full" })] }, `rule-sample-facts-skeleton-${index}`))) }));
+    }
+    if (error) {
+        return (_jsx(Banner, { type: "error", label: "Could not load sample facts", description: error instanceof Error ? error.message : "SPARQL query failed", size: "loose" }));
+    }
+    if (!isPresent(samples)) {
+        return _jsx("p", { className: "typography-small text-muted-foreground", children: "No inferred facts found for this rule." });
+    }
+    return (_jsx("div", { className: "overflow-hidden rounded-md border border-muted-border bg-card/70", children: samples.map((sample) => {
+            const key = sampleKey(sample);
+            const resolution = personalDataResolutions.get(sample.predicate);
+            const personalDataCategories = resolution?.status === "resolved" && isPresent(resolution.categories) ? resolution.categories : undefined;
+            const isEntityObject = isPresent(ontologyTermIri(sample.object));
+            const maskObject = isPresent(personalDataCategories) && !isEntityObject;
+            const maskedWhilePending = resolution !== undefined && resolution.status !== "resolved" && !isEntityObject;
+            return (_jsxs("div", { className: "flex w-full items-center gap-3 border-b border-muted-border px-3 py-2 transition-colors last:border-b-0 hover:bg-muted/50", children: [_jsxs("span", { className: "flex min-w-0 flex-1 flex-wrap items-center gap-x-1.5 gap-y-0.5 typography-tiny", children: [_jsx(OntologyTermText, { term: sample.subject, fallbackLabel: humanizeEntityName(iriLocalName(sample.subject)) }), _jsx(OntologyTermText, { term: sample.predicate, className: "whitespace-nowrap text-muted-foreground" }), maskedWhilePending ? (_jsx("span", { className: "tracking-wider text-muted-foreground", children: maskText })) : maskObject && personalDataCategories ? (_jsx(MaskedValue, { value: sample.object, categories: personalDataCategories })) : (_jsx(OntologyTermText, { term: sample.object, fallbackLabel: humanizeEntityName(iriLocalName(sample.object)) }))] }), _jsx(Button, { asChild: true, variant: "tertiary", size: "xs", icon: ExternalLink, children: _jsx(Link, { to: buildExplainPath({ ...sample, namedGraph: sample.graph }), children: "Open in /explain" }) })] }, key));
+        }) }));
+}
+function sampleKey(sample) {
+    return `${sample.subject}|${sample.predicate}|${sample.object}|${sample.graph ?? ""}|${sample.objectDatatype ?? ""}`;
+}

package/dist/routes/rules/components/RulesOverviewHeaderActions.d.ts

@@ -0,0 +1,17 @@
+import type { Awaitable } from "@manta-eu/lib/types";
+export type RulesOverviewHeaderActionsProps = {
+    activeTab: "rules" | "actionShapes";
+    hasStagedRules: boolean;
+    isRefreshing: boolean;
+    isClearStagedPending: boolean;
+    isValidatePending: boolean;
+    isCommitPending: boolean;
+    onRefresh: () => void;
+    onShowDependencyGraph: () => void;
+    onClearStaged: () => Awaitable<void>;
+    onValidate: () => Awaitable<void>;
+    onCommit: () => Awaitable<void>;
+    onCreateRule: () => void;
+};
+export declare function RulesOverviewHeaderActions(props: RulesOverviewHeaderActionsProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RulesOverviewHeaderActions.d.ts.map

package/dist/routes/rules/components/RulesOverviewHeaderActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RulesOverviewHeaderActions.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RulesOverviewHeaderActions.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAIrD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,SAAS,EAAE,OAAO,GAAG,cAAc,CAAC;IACpC,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,aAAa,EAAE,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC;IACrC,UAAU,EAAE,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC;IAClC,QAAQ,EAAE,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,+BAA+B,2CAuEhF"}

package/dist/routes/rules/components/RulesOverviewHeaderActions.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CheckCircle, GitCommit, Plus, RefreshCcw, Trash } from "lucide-react";
+import { PageHeaderActions } from "#components/layouts/page/index";
+export function RulesOverviewHeaderActions(props) {
+    const { activeTab, hasStagedRules, isRefreshing, isClearStagedPending, isValidatePending, isCommitPending, onRefresh, 
+    //onShowDependencyGraph,
+    onClearStaged, onValidate, onCommit, onCreateRule, } = props;
+    const actions = [
+        {
+            key: "refresh",
+            label: "Refresh",
+            onClick: onRefresh,
+            icon: RefreshCcw,
+            variant: "tertiary",
+            disabled: isRefreshing,
+            iconOnly: true,
+        },
+    ];
+    if (activeTab === "rules") {
+        // hiding until performance issues fixed
+        // actions.push({
+        //   key: "show-graph",
+        //   label: "Show Graph",
+        //   onClick: onShowDependencyGraph,
+        //   icon: Network,
+        //   variant: "secondary",
+        //   disabled: true,
+        // });
+        if (hasStagedRules) {
+            actions.push({
+                key: "clear-staged",
+                label: "Clear Staged",
+                onClick: () => void onClearStaged(),
+                icon: Trash,
+                variant: "secondary",
+                disabled: isClearStagedPending,
+            }, {
+                key: "validate",
+                label: "Validate",
+                onClick: () => void onValidate(),
+                icon: CheckCircle,
+                variant: "secondary",
+                disabled: isValidatePending,
+            }, {
+                key: "commit",
+                label: "Commit Changes",
+                onClick: () => void onCommit(),
+                icon: GitCommit,
+                disabled: isCommitPending,
+            });
+        }
+        actions.push({ key: "new-rule", label: "New Rule", onClick: onCreateRule, icon: Plus });
+    }
+    return _jsx(PageHeaderActions, { actions: actions });
+}

package/dist/routes/rules/components/RulesOverviewPage.d.ts

@@ -0,0 +1,13 @@
+import type { GQLRule } from "@manta-eu/client";
+import { type ReactNode } from "react";
+import { type SupportedActionShapeRef } from "./rule-actionability.js";
+export type RulesOverviewPageProps = {
+    rules: GQLRule[];
+    supportedActionShapes?: readonly SupportedActionShapeRef[];
+    ownerNameByUserId?: ReadonlyMap<string, string>;
+    tabs?: ReactNode;
+    isLoading?: boolean;
+    error?: string | null;
+};
+export declare function RulesOverviewPage(props: RulesOverviewPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RulesOverviewPage.d.ts.map

package/dist/routes/rules/components/RulesOverviewPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RulesOverviewPage.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RulesOverviewPage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAOhD,OAAO,EAAmC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIxE,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAmE9B,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,qBAAqB,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC3D,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAoEF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,2CA2W9D"}