akanjs 3.0.2 → 3.1.0-rc.0

package/ui/BottomSheet.tsx

@@ -1,19 +1,21 @@
 "use client";
 import { useDrag } from "@use-gesture/react";
 import { cn } from "akanjs/client";
-import { st } from "akanjs/store";
-import { animated } from "akanjs/ui";
-import { useEscapeKey } from "akanjs/webkit";
+import { useBodyScrollLock, useEscapeKey } from "akanjs/webkit";
 import { forwardRef, type ReactNode, useEffect, useImperativeHandle, useRef, useState } from "react";
+import { createPortal } from "react-dom";
 import { BiX } from "react-icons/bi";
 import { config, useSpring } from "react-spring";
+import { animated } from "./animated";
 import { buttonRecipe } from "./Button";
+import { overlayZ, useOverlayLayerProps, useOverlayPortal } from "./overlayLayer";
 
 interface BottomSheetProps {
   className?: string;
   bodyClassName?: string;
   /** Left out, the sheet opens from its own trigger and handle. */
   open?: boolean;
+  /** Called once when the person dismisses the sheet: the backdrop, Escape, a drag down, or the close button. */
   onCancel?: () => void;
   trigger?: ReactNode;
   /** Whole top row of the sheet, replacing the drag handle or the close row. */
@@ -50,44 +52,51 @@ export const BottomSheet = forwardRef<BottomSheetRef, BottomSheetProps>(
     bottomSheetRef,
   ) => {
     const ref = useRef<HTMLDivElement>(null);
-    const pageState = st.use.pageState({ agent: false });
+    const shown = useRef(false);
+    const portal = useOverlayPortal();
+    const overlayLayerProps = useOverlayLayerProps();
     const [selfOpen, setSelfOpen] = useState(false);
     const isOpen = open ?? selfOpen;
 
     const [{ y, opacity }, api] = useSpring(() => ({ y: OFFSCREEN, opacity: 0 }));
 
-    const openModal = async () => {
-      setSelfOpen(true);
+    const show = async () => {
+      shown.current = true;
       await Promise.all(api.start({ y: 0, opacity: 1, immediate: false, config: config.default }));
     };
-    const closeModal = async () => {
+    const hide = async () => {
       const height = ref.current?.clientHeight ?? OFFSCREEN;
       await Promise.all(
         api.start({ y: height, opacity: 0, immediate: false, config: { ...config.stiff, velocity: 0 } }),
       );
-      setSelfOpen(false);
+    };
+    
+    const dismiss = () => {
+      if (open === undefined) setSelfOpen(false);
       onCancel?.();
     };
 
     const bind = useDrag(({ down, movement: [, my] }) => {
       const height = ref.current?.clientHeight ?? OFFSCREEN;
       if (down) void api.start({ y: Math.max(0, my), immediate: true });
-      else if (my > height / 3) void closeModal();
-      else void openModal();
+      else if (my > height / 3) dismiss();
+      else void show();
     });
 
     useImperativeHandle(bottomSheetRef, () => ({
-      open: openModal,
-      close: closeModal,
+      open: () => {
+        setSelfOpen(true);
+        void show();
+      },
+      close: dismiss,
     }));
 
-    useEscapeKey(isOpen, () => {
-      void closeModal();
-    });
+    useEscapeKey(isOpen, dismiss);
+    useBodyScrollLock(isOpen);
 
     useEffect(() => {
-      if (isOpen) void openModal();
-      else void closeModal();
+      if (isOpen) void show();
+      else if (shown.current) void hide();
     }, [isOpen]);
 
     return (
@@ -102,43 +111,63 @@ export const BottomSheet = forwardRef<BottomSheetRef, BottomSheetProps>(
             {trigger}
           </div>
         ) : null}
-        <animated.div
-          style={{ opacity }}
-          onClick={() => void closeModal()}
-          className={cn("fixed inset-0 bg-black/50 backdrop-blur-sm", isOpen ? "z-50" : "-z-[1]")}
-        />
-        <animated.div
-          ref={ref}
-          style={{ y, paddingTop: type === "full" ? pageState.topSafeArea : 0 }}
-          className={cn(
-            "fixed bottom-0 left-0 z-[101] flex w-full flex-col bg-card text-card-foreground",
-            type === "half" && "h-[90dvh] rounded-t-box border-border border-t shadow-2xl",
-            type === "full" && "h-[100dvh]",
-            className,
-          )}
-        >
-          {header ??
-            (type === "half" ? (
-              <animated.div {...bind()} className="flex shrink-0 cursor-grab touch-pan-y justify-center py-3">
-                {handle ?? <div className="h-1 w-10 rounded-full bg-foreground/15" />}
-              </animated.div>
-            ) : (
-              <div className="flex shrink-0 justify-end p-2" style={{ paddingTop: pageState.topSafeArea }}>
-                <div className="contents" onClick={() => void closeModal()}>
-                  {close ?? (
-                    <button
-                      aria-label="Close"
-                      className={buttonRecipe({ variant: "ghost", size: "icon" }, "rounded-full text-foreground/50")}
-                      type="button"
-                    >
-                      <BiX className="text-2xl" />
-                    </button>
+        {portal
+          ? createPortal(
+              <>
+                <animated.div
+                  {...overlayLayerProps}
+                  style={{ opacity, zIndex: overlayZ.modal, pointerEvents: isOpen ? "auto" : "none" }}
+                  onClick={dismiss}
+                  className="fixed inset-0 bg-black/50 backdrop-blur-sm"
+                />
+                <animated.div
+                  {...overlayLayerProps}
+                  ref={ref}
+                  style={{ y, zIndex: overlayZ.modal }}
+                  className={cn(
+                    "fixed bottom-0 left-0 flex w-full flex-col bg-card text-card-foreground",
+                    type === "half" && "h-[90dvh] rounded-t-box border-border border-t shadow-2xl",
+                    type === "full" &&
+                      "h-[100dvh] pt-[max(var(--akan-top-safe-area,0px),env(safe-area-inset-top,0px))]",
+                    className,
                   )}
-                </div>
-              </div>
-            ))}
-          <div className={cn("scrollbar-thin min-h-0 flex-1 overflow-y-auto px-4 pb-4", bodyClassName)}>{children}</div>
-        </animated.div>
+                >
+                  {header ??
+                    (type === "half" ? (
+                      <animated.div {...bind()} className="flex shrink-0 cursor-grab touch-pan-y justify-center py-3">
+                        {handle ?? <div className="h-1 w-10 rounded-full bg-foreground/15" />}
+                      </animated.div>
+                    ) : (
+                      <div className="flex shrink-0 justify-end p-2">
+                        <div className="contents" onClick={dismiss}>
+                          {close ?? (
+                            <button
+                              aria-label="Close"
+                              className={buttonRecipe(
+                                { variant: "ghost", size: "icon" },
+                                "rounded-full text-foreground/50",
+                              )}
+                              type="button"
+                            >
+                              <BiX className="text-2xl" />
+                            </button>
+                          )}
+                        </div>
+                      </div>
+                    ))}
+                  <div
+                    className={cn(
+                      "scrollbar-thin min-h-0 flex-1 overflow-y-auto px-4 pb-[calc(1rem+max(var(--akan-bottom-safe-area,0px),env(safe-area-inset-bottom,0px)))]",
+                      bodyClassName,
+                    )}
+                  >
+                    {children}
+                  </div>
+                </animated.div>
+              </>,
+              portal,
+            )
+          : null}
       </>
     );
   },

package/ui/Constant/Doc.tsx

@@ -2,7 +2,7 @@
 
 import { usePage } from "akanjs/client";
 import { capitalize } from "akanjs/common";
-import { useMemo, useState } from "react";
+import { Fragment, useMemo, useState } from "react";
 import { AiOutlineInfoCircle, AiOutlineSearch } from "react-icons/ai";
 import { BiNetworkChart, BiTable } from "react-icons/bi";
 
@@ -24,12 +24,16 @@ import {
   SummaryGrid,
   Toolbar,
 } from "../Reference";
+import { originText, ownerOf } from "../Reference/origin";
 import { Graph } from "./Graph";
 import {
+  type ConstantSchemaOptions,
   type DatabaseModelVariant,
   type DatabaseSchema,
   databaseModelVariants,
+  type EnumSchema,
   type FieldSchema,
+  getConstantOwnerOrder,
   getConstantSchemaDoc,
   getDefaultVariant,
   getVariantTitle,
@@ -37,10 +41,6 @@ import {
 } from "./schemaDoc";
 import type { SchemaGraphEdge, SchemaGraphNode, SchemaNodeKind } from "./schemaGraph";
 
-export default function Doc() {
-  return <div />;
-}
-
 const docText = {
   pageTitle: { en: "Constant Schema Docs", ko: "Constant 스키마 문서" },
   printTitle: { en: "Constant Schema Definition", ko: "Constant 스키마 정의서" },
@@ -77,6 +77,7 @@ const docText = {
   selectedModel: { en: "Selected Model", ko: "선택한 모델" },
   external: { en: "External", ko: "외부" },
   selectNode: { en: "Select a node in the diagram.", ko: "다이어그램에서 노드를 선택하세요." },
+  unknownOrigin: { en: "Unknown library", ko: "출처 미상" },
 } as const;
 
 const fieldCountText = (count: number) => ({ en: `${count} fields`, ko: `필드 ${count}개` });
@@ -97,16 +98,17 @@ const headsOf = (l: ReturnType<typeof usePage>["l"], keys: (keyof typeof docText
 
 const printTable = "print:overflow-visible print:rounded-none print:border-0";
 
-interface ZoneProps {
-  models?: string[];
-  scalars?: string[];
-  enums?: string[];
+export interface ZoneProps extends ConstantSchemaOptions {
   openAll?: boolean;
+  groupBy?: "lib";
 }
 
-const Zone = ({ models, scalars, enums, openAll }: ZoneProps) => {
+export const Zone = ({ models, scalars, enums, include, exclude, libs, openAll, groupBy }: ZoneProps) => {
   const { l } = usePage();
-  const schemaDoc = useMemo(() => getConstantSchemaDoc({ models, scalars, enums }), [models, scalars, enums]);
+  const schemaDoc = useMemo(
+    () => getConstantSchemaDoc({ models, scalars, enums, include, exclude, libs }),
+    [models, scalars, enums, include, exclude, libs],
+  );
   const viewItems = [
     { key: "table", label: l.trans(docText.table), icon: <BiTable /> },
     { key: "diagram", label: l.trans(docText.diagram), icon: <BiNetworkChart /> },
@@ -128,6 +130,19 @@ const Zone = ({ models, scalars, enums, openAll }: ZoneProps) => {
       ),
     [schemaDoc.enums, query],
   );
+  const groups = useMemo(() => {
+    const owners = groupBy === "lib" ? [...getConstantOwnerOrder(), ""] : [null];
+    const inGroup = (owner: string | null) => (entry: { origin: string[] }) =>
+      owner === null || (ownerOf(entry.origin) ?? "") === owner;
+    return owners
+      .map((owner) => ({
+        owner,
+        databases: filteredDatabases.filter(inGroup(owner)),
+        scalars: filteredScalars.filter(inGroup(owner)),
+        enums: filteredEnums.filter(inGroup(owner)),
+      }))
+      .filter((group) => group.owner === null || group.databases.length + group.scalars.length + group.enums.length);
+  }, [groupBy, filteredDatabases, filteredScalars, filteredEnums]);
   return (
     <div className="flex break-after-page flex-col gap-6">
       <div className="flex flex-col gap-1">
@@ -152,45 +167,81 @@ const Zone = ({ models, scalars, enums, openAll }: ZoneProps) => {
         />
         <Segmented className="ml-auto" items={viewItems} onChange={setViewMode} value={viewMode} />
       </Toolbar>
-      {viewMode === "diagram" ? (
-        <Diagram databases={filteredDatabases} scalars={filteredScalars} />
-      ) : (
-        <div className="flex flex-col gap-6">
-          <Section title={l.trans(docText.databaseModels)}>
-            {filteredDatabases.length ? (
-              <div className="flex flex-col gap-2">
-                {filteredDatabases.map((database) => (
-                  <Model key={database.refName} database={database} openAll={openAll} />
-                ))}
-              </div>
-            ) : (
-              <div className={docUi.emptyPanel}>{l.trans(docText.noDatabaseMatch)}</div>
-            )}
-          </Section>
-          {filteredScalars.length ? (
-            <Section title={l.trans(docText.scalarModels)}>
-              <div className="flex flex-col gap-2">
-                {filteredScalars.map((scalar) => (
-                  <Scalar key={scalar.refName} scalar={scalar} openAll={openAll} />
-                ))}
-              </div>
-            </Section>
-          ) : null}
-          {filteredEnums.length ? (
-            <Section title={l.trans(docText.enums)}>
-              <EnumList enums={filteredEnums} />
-            </Section>
-          ) : null}
-        </div>
-      )}
+      {groups.map(({ owner, databases, scalars: groupScalars, enums: groupEnums }) => {
+        const body =
+          viewMode === "diagram" ? (
+            <Diagram databases={databases} scalars={groupScalars} />
+          ) : (
+            <SchemaTables
+              databases={databases}
+              scalars={groupScalars}
+              enums={groupEnums}
+              openAll={openAll}
+              showEmpty={owner === null}
+            />
+          );
+        if (owner === null) return <Fragment key="all">{body}</Fragment>;
+        return (
+          <section className="flex flex-col gap-4" key={owner}>
+            <h2 className="border-border border-b pb-2 font-bold font-mono text-2xl">
+              {owner || l.trans(docText.unknownOrigin)}
+            </h2>
+            {body}
+          </section>
+        );
+      })}
     </div>
   );
 };
-Doc.Zone = Zone;
 
-const Print = ({ models, scalars, enums }: ZoneProps) => {
+interface SchemaTablesProps {
+  databases: DatabaseSchema[];
+  scalars: ScalarSchema[];
+  enums: EnumSchema[];
+  openAll?: boolean;
+  showEmpty: boolean;
+}
+const SchemaTables = ({ databases, scalars, enums, openAll, showEmpty }: SchemaTablesProps) => {
   const { l } = usePage();
-  const schemaDoc = useMemo(() => getConstantSchemaDoc({ models, scalars, enums }), [models, scalars, enums]);
+  return (
+    <div className="flex flex-col gap-6">
+      {databases.length || showEmpty ? (
+        <Section title={l.trans(docText.databaseModels)}>
+          {databases.length ? (
+            <div className="flex flex-col gap-2">
+              {databases.map((database) => (
+                <Model key={database.refName} database={database} openAll={openAll} />
+              ))}
+            </div>
+          ) : (
+            <div className={docUi.emptyPanel}>{l.trans(docText.noDatabaseMatch)}</div>
+          )}
+        </Section>
+      ) : null}
+      {scalars.length ? (
+        <Section title={l.trans(docText.scalarModels)}>
+          <div className="flex flex-col gap-2">
+            {scalars.map((scalar) => (
+              <Scalar key={scalar.refName} scalar={scalar} openAll={openAll} />
+            ))}
+          </div>
+        </Section>
+      ) : null}
+      {enums.length ? (
+        <Section title={l.trans(docText.enums)}>
+          <EnumList enums={enums} />
+        </Section>
+      ) : null}
+    </div>
+  );
+};
+
+export const Print = ({ models, scalars, enums, include, exclude, libs }: ZoneProps) => {
+  const { l } = usePage();
+  const schemaDoc = useMemo(
+    () => getConstantSchemaDoc({ models, scalars, enums, include, exclude, libs }),
+    [models, scalars, enums, include, exclude, libs],
+  );
   return (
     <div className="flex flex-col gap-10 bg-background text-foreground print:bg-white print:text-black">
       <div className="break-after-page">
@@ -223,17 +274,17 @@ const Print = ({ models, scalars, enums }: ZoneProps) => {
     </div>
   );
 };
-Doc.Print = Print;
-
-interface ModelProps {
+export interface ModelProps {
   refName?: string;
   database?: DatabaseSchema;
   openAll?: boolean;
 }
 
-const Model = ({ refName, database: databaseProp, openAll }: ModelProps) => {
+export const Model = ({ refName, database: databaseProp, openAll }: ModelProps) => {
   const database = useMemo(
-    () => databaseProp ?? getConstantSchemaDoc({ models: refName ? [refName] : [] }).databases.at(0),
+    () =>
+      databaseProp ??
+      getConstantSchemaDoc({ models: refName ? [refName] : [], scalars: [], enums: [] }).databases.at(0),
     [databaseProp, refName],
   );
   const [variant, setVariant] = useState<DatabaseModelVariant>("full");
@@ -248,6 +299,9 @@ const Model = ({ refName, database: databaseProp, openAll }: ModelProps) => {
           <div className="flex flex-wrap items-center gap-2">
             <span className="font-bold text-lg">{database.modelName}</span>
             <span className={docPill("info", "font-mono")}>{database.refName}</span>
+            {database.origin.length ? (
+              <span className={docPill("muted", "font-mono")}>{l.trans(originText(database.origin))}</span>
+            ) : null}
           </div>
           <div className="text-foreground/55 text-sm">{l._(`${database.refName}.modelDesc`)}</div>
         </div>
@@ -258,17 +312,16 @@ const Model = ({ refName, database: databaseProp, openAll }: ModelProps) => {
     </Collapse>
   );
 };
-Doc.Model = Model;
-
-interface ScalarProps {
+export interface ScalarProps {
   refName?: string;
   scalar?: ScalarSchema;
   openAll?: boolean;
 }
 
-const Scalar = ({ refName, scalar: scalarProp, openAll }: ScalarProps) => {
+export const Scalar = ({ refName, scalar: scalarProp, openAll }: ScalarProps) => {
   const scalar = useMemo(
-    () => scalarProp ?? getConstantSchemaDoc({ scalars: refName ? [refName] : [] }).scalars.at(0),
+    () =>
+      scalarProp ?? getConstantSchemaDoc({ models: [], scalars: refName ? [refName] : [], enums: [] }).scalars.at(0),
     [scalarProp, refName],
   );
   const { l } = usePage();
@@ -281,6 +334,9 @@ const Scalar = ({ refName, scalar: scalarProp, openAll }: ScalarProps) => {
           <div className="flex flex-wrap items-center gap-2">
             <span className="font-bold text-lg">{scalar.modelName}</span>
             <span className={docPill("muted", "font-mono")}>{scalar.refName}</span>
+            {scalar.origin.length ? (
+              <span className={docPill("muted", "font-mono")}>{l.trans(originText(scalar.origin))}</span>
+            ) : null}
           </div>
           <div className="text-foreground/55 text-sm">{l._(`${scalar.refName}.modelDesc`)}</div>
         </div>
@@ -290,13 +346,11 @@ const Scalar = ({ refName, scalar: scalarProp, openAll }: ScalarProps) => {
     </Collapse>
   );
 };
-Doc.Scalar = Scalar;
-
-interface EnumProps {
+export interface EnumProps {
   enums?: ReturnType<typeof getConstantSchemaDoc>["enums"];
 }
 
-const EnumList = ({ enums = getConstantSchemaDoc().enums }: EnumProps) => {
+export const EnumList = ({ enums = getConstantSchemaDoc().enums }: EnumProps) => {
   const { l } = usePage();
   return (
     <DocTable head={headsOf(l, ["enum", "type", "values", "usedBy"])}>
@@ -343,7 +397,6 @@ const EnumList = ({ enums = getConstantSchemaDoc().enums }: EnumProps) => {
     </DocTable>
   );
 };
-Doc.Enum = EnumList;
 
 const ModelVariantTable = ({ variant }: { variant: ReturnType<typeof getDefaultVariant> }) => {
   const { l } = usePage();

package/ui/Constant/index.ts

@@ -1,7 +1,7 @@
-import Doc from "./Doc";
+import { EnumList, Model, Print, Scalar, Zone } from "./Doc";
 import { Graph } from "./Graph";
 
 export * from "./schemaDoc";
 export * from "./schemaGraph";
 
-export const Constant = { Doc, Graph };
+export const Constant = { Doc: { Zone, Print, Model, Scalar, Enum: EnumList }, Graph };

package/ui/Constant/schemaDoc.ts

@@ -11,17 +11,26 @@ import {
   type ConstantCls,
   type ConstantField,
   type ConstantModel,
+  type ConstantOriginKind,
   ConstantRegistry,
   type TextFieldRole,
 } from "akanjs/constant";
+import { ownerOf, ownerOrderOf } from "../Reference/origin";
 
 export const databaseModelVariants = ["input", "object", "full", "light", "insight"] as const;
 export type DatabaseModelVariant = (typeof databaseModelVariants)[number];
 
+/**
+ * `undefined` is "every registered one" and `[]` is "none". Once any option narrows the scope, scalars default to
+ * the ones the shown models embed and enums to the ones the shown models and scalars use.
+ */
 export interface ConstantSchemaOptions {
   models?: string[];
   scalars?: string[];
   enums?: string[];
+  include?: string[];
+  exclude?: string[];
+  libs?: string[];
 }
 
 export interface ConstantSchemaDoc {
@@ -34,6 +43,7 @@ export interface ConstantSchemaDoc {
 export interface DatabaseSchema {
   kind: "database";
   refName: string;
+  origin: string[];
   modelName: string;
   variants: Record<DatabaseModelVariant, ModelVariantSchema>;
 }
@@ -41,6 +51,7 @@ export interface DatabaseSchema {
 export interface ScalarSchema {
   kind: "scalar";
   refName: string;
+  origin: string[];
   modelName: string;
   modelRef: ConstantCls;
   fields: FieldSchema[];
@@ -57,6 +68,7 @@ export interface ModelVariantSchema {
 export interface EnumSchema {
   key: string;
   refName: string;
+  origin: string[];
   typeName: string;
   values: (string | number)[];
   enumRef: EnumInstance;
@@ -105,33 +117,80 @@ export interface FieldSchema {
 }
 
 export const getConstantSchemaDoc = (options: ConstantSchemaOptions = {}): ConstantSchemaDoc => {
-  const databases = getSelectedEntries(ConstantRegistry.database, options.models).map(([refName, model]) =>
-    buildDatabaseSchema(refName, model),
-  );
-  const scalars = getSelectedEntries(ConstantRegistry.scalar, options.scalars).map(([refName, scalar]) => {
-    const modelRef = scalar.model;
-    return {
-      kind: "scalar" as const,
-      refName,
-      modelName: getModelName(modelRef, refName),
-      modelRef,
-      fields: getFields(modelRef, "scalar"),
-    };
-  });
-  const selectedEnums = getSelectedEntries(ConstantRegistry.enum, options.enums);
+  const { models, scalars: scalarKeys, enums: enumKeys, include, exclude, libs } = options;
+  const isScoped = [models, scalarKeys, enumKeys, include, exclude, libs].some((option) => option !== undefined);
+  const keeps = (kind: ConstantOriginKind) => (key: string) =>
+    !exclude?.includes(key) && (!libs || libs.includes(ownerOf(ConstantRegistry.getOrigin(kind, key)) ?? ""));
+  const isRoot = (key: string) => keeps("database")(key) && (!include || include.includes(key));
+  const databases = selectKeys(ConstantRegistry.database, models)
+    .filter(isRoot)
+    .map((refName) => buildDatabaseSchema(refName, ConstantRegistry.getDatabase(refName)));
+  const scalars = (
+    scalarKeys !== undefined
+      ? selectKeys(ConstantRegistry.scalar, scalarKeys).filter(keeps("scalar"))
+      : isScoped
+        ? collectEmbeddedScalars(
+            databases,
+            include ? selectKeys(ConstantRegistry.scalar, include).filter(keeps("scalar")) : [],
+            keeps("scalar"),
+          )
+        : selectKeys(ConstantRegistry.scalar)
+  ).map(buildScalarSchema);
   const enumUsages = collectEnumUsages(databases, scalars);
-  const enums = selectedEnums.map(([key, enumRef]) => ({
+  const enums = selectKeys(ConstantRegistry.enum, enumKeys)
+    .filter(keeps("enum"))
+    .map((key) => buildEnumSchema(key, enumUsages))
+    .filter((enumSchema) => enumKeys !== undefined || !isScoped || enumSchema.usedBy.length);
+  const relations = collectRelations(databases, scalars);
+  return { databases, scalars, enums, relations };
+};
+
+const buildScalarSchema = (refName: string): ScalarSchema => {
+  const modelRef = ConstantRegistry.getScalar(refName).model;
+  return {
+    kind: "scalar",
+    refName,
+    origin: ConstantRegistry.getOrigin("scalar", refName),
+    modelName: getModelName(modelRef, refName),
+    modelRef,
+    fields: getFields(modelRef, "scalar"),
+  };
+};
+
+const buildEnumSchema = (key: string, enumUsages: Map<EnumInstance, EnumUsage[]>): EnumSchema => {
+  const enumRef = ConstantRegistry.enum.get(key) as EnumInstance;
+  return {
     key,
     refName: enumRef.refName,
+    origin: ConstantRegistry.getOrigin("enum", key),
     typeName: PrimitiveRegistry.getName(enumRef.type as typeof PrimitiveScalar),
     values: [...enumRef.values] as (string | number)[],
     enumRef,
     usedBy: enumUsages.get(enumRef) ?? [],
-  }));
-  const relations = collectRelations(databases, scalars);
-  return { databases, scalars, enums, relations };
+  };
+};
+
+const collectEmbeddedScalars = (
+  databases: DatabaseSchema[],
+  rootScalars: string[],
+  isKept: (key: string) => boolean,
+) => {
+  const found = new Set(rootScalars);
+  const visit = (fields: FieldSchema[]) => {
+    for (const field of fields) {
+      const refName = field.typeRefName;
+      if (!refName || found.has(refName) || !isKept(refName) || !ConstantRegistry.scalar.has(refName)) continue;
+      found.add(refName);
+      visit(getFields(ConstantRegistry.getScalar(refName).model, "scalar"));
+    }
+  };
+  for (const database of databases) for (const variant of Object.values(database.variants)) visit(variant.fields);
+  for (const refName of rootScalars) visit(getFields(ConstantRegistry.getScalar(refName).model, "scalar"));
+  return [...found].sort((a, b) => a.localeCompare(b));
 };
 
+export const getConstantOwnerOrder = () => ownerOrderOf([...ConstantRegistry.origin.values()]);
+
 export const getDefaultVariant = (database: DatabaseSchema): ModelVariantSchema => database.variants.full;
 
 export const getVariantTitle = (variant: DatabaseModelVariant | "scalar") => {
@@ -155,7 +214,13 @@ const buildDatabaseSchema = (refName: string, model: ConstantModel): DatabaseSch
       ];
     }),
   ) as Record<DatabaseModelVariant, ModelVariantSchema>;
-  return { kind: "database", refName, modelName: ConstantRegistry.getModelName(model.full), variants };
+  return {
+    kind: "database",
+    refName,
+    origin: ConstantRegistry.getOrigin("database", refName),
+    modelName: ConstantRegistry.getModelName(model.full),
+    variants,
+  };
 };
 
 const getFields = (modelRef: ConstantCls, variant: DatabaseModelVariant | "scalar"): FieldSchema[] =>
@@ -265,13 +330,8 @@ const getConstraints = (props: ReturnType<ConstantField["getProps"]>) =>
     props.accumulate ? "accumulate" : null,
   ].filter((constraint): constraint is string => !!constraint);
 
-const getSelectedEntries = <Value>(map: Map<string, Value>, selected?: string[]): [string, Value][] => {
-  if (!selected?.length) return [...map.entries()].sort(([a], [b]) => a.localeCompare(b));
-  return selected.flatMap((key) => {
-    const value = map.get(key);
-    return value ? ([[key, value]] as [string, Value][]) : [];
-  });
-};
+const selectKeys = (map: Map<string, unknown>, selected?: string[]) =>
+  selected ? selected.filter((key) => map.has(key)) : [...map.keys()].sort((a, b) => a.localeCompare(b));
 
 const collectEnumUsages = (databases: DatabaseSchema[], scalars: ScalarSchema[]) => {
   const usages = new Map<EnumInstance, EnumUsage[]>();