add published lexicons flow when adding a lexicon

frontend-v2/src/__generated__/PublishedLexiconsListQuery.graphql.ts

···
+/**
+ * @generated SignedSource<<af4ff104aee13ec3df07677ea9ef9ce7>>
+ * @lightSyntaxTransform
+ * @nogrep
+ */
+
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { ConcreteRequest } from 'relay-runtime';
+export type SliceRecordsWhereInput = {
+  cid?: StringFilter | null | undefined;
+  collection?: StringFilter | null | undefined;
+  did?: StringFilter | null | undefined;
+  indexedAt?: DateTimeFilter | null | undefined;
+  json?: StringFilter | null | undefined;
+  or?: ReadonlyArray<SliceRecordsWhereInput | null | undefined> | null | undefined;
+  uri?: StringFilter | null | undefined;
+};
+export type StringFilter = {
+  contains?: string | null | undefined;
+  eq?: string | null | undefined;
+  fuzzy?: string | null | undefined;
+  gt?: string | null | undefined;
+  gte?: string | null | undefined;
+  in?: ReadonlyArray<string | null | undefined> | null | undefined;
+  lt?: string | null | undefined;
+  lte?: string | null | undefined;
+};
+export type DateTimeFilter = {
+  eq?: string | null | undefined;
+  gt?: string | null | undefined;
+  gte?: string | null | undefined;
+  lt?: string | null | undefined;
+  lte?: string | null | undefined;
+};
+export type PublishedLexiconsListQuery$variables = {
+  sliceUri: string;
+  where?: SliceRecordsWhereInput | null | undefined;
+};
+export type PublishedLexiconsListQuery$data = {
+  readonly sliceRecords: {
+    readonly edges: ReadonlyArray<{
+      readonly node: {
+        readonly collection: string;
+        readonly uri: string;
+        readonly value: string;
+      };
+    }>;
+  };
+};
+export type PublishedLexiconsListQuery = {
+  response: PublishedLexiconsListQuery$data;
+  variables: PublishedLexiconsListQuery$variables;
+};
+
+const node: ConcreteRequest = (function(){
+var v0 = [
+  {
+    "defaultValue": null,
+    "kind": "LocalArgument",
+    "name": "sliceUri"
+  },
+  {
+    "defaultValue": null,
+    "kind": "LocalArgument",
+    "name": "where"
+  }
+],
+v1 = [
+  {
+    "alias": null,
+    "args": [
+      {
+        "kind": "Literal",
+        "name": "first",
+        "value": 1000
+      },
+      {
+        "kind": "Variable",
+        "name": "sliceUri",
+        "variableName": "sliceUri"
+      },
+      {
+        "kind": "Variable",
+        "name": "where",
+        "variableName": "where"
+      }
+    ],
+    "concreteType": "SliceRecordsConnection",
+    "kind": "LinkedField",
+    "name": "sliceRecords",
+    "plural": false,
+    "selections": [
+      {
+        "alias": null,
+        "args": null,
+        "concreteType": "SliceRecordEdge",
+        "kind": "LinkedField",
+        "name": "edges",
+        "plural": true,
+        "selections": [
+          {
+            "alias": null,
+            "args": null,
+            "concreteType": "SliceRecord",
+            "kind": "LinkedField",
+            "name": "node",
+            "plural": false,
+            "selections": [
+              {
+                "alias": null,
+                "args": null,
+                "kind": "ScalarField",
+                "name": "uri",
+                "storageKey": null
+              },
+              {
+                "alias": null,
+                "args": null,
+                "kind": "ScalarField",
+                "name": "collection",
+                "storageKey": null
+              },
+              {
+                "alias": null,
+                "args": null,
+                "kind": "ScalarField",
+                "name": "value",
+                "storageKey": null
+              }
+            ],
+            "storageKey": null
+          }
+        ],
+        "storageKey": null
+      }
+    ],
+    "storageKey": null
+  }
+];
+return {
+  "fragment": {
+    "argumentDefinitions": (v0/*: any*/),
+    "kind": "Fragment",
+    "metadata": null,
+    "name": "PublishedLexiconsListQuery",
+    "selections": (v1/*: any*/),
+    "type": "Query",
+    "abstractKey": null
+  },
+  "kind": "Request",
+  "operation": {
+    "argumentDefinitions": (v0/*: any*/),
+    "kind": "Operation",
+    "name": "PublishedLexiconsListQuery",
+    "selections": (v1/*: any*/)
+  },
+  "params": {
+    "cacheID": "9376c8881ba959a67c32afef675e6baa",
+    "id": null,
+    "metadata": {},
+    "name": "PublishedLexiconsListQuery",
+    "operationKind": "query",
+    "text": "query PublishedLexiconsListQuery(\n  $sliceUri: String!\n  $where: SliceRecordsWhereInput\n) {\n  sliceRecords(sliceUri: $sliceUri, first: 1000, where: $where) {\n    edges {\n      node {\n        uri\n        collection\n        value\n      }\n    }\n  }\n}\n"
+  }
+};
+})();
+
+(node as any).hash = "c51dfb1274d633dc4db99d903954a58e";
+
+export default node;

frontend-v2/src/components/CreateLexiconDialog.tsx

···
 import { FormControl } from "./FormControl.tsx";
 import { Textarea } from "./Textarea.tsx";
 import { Button } from "./Button.tsx";
+import { PublishedLexiconsList } from "./PublishedLexiconsList.tsx";
 import type { CreateLexiconDialogMutation } from "../__generated__/CreateLexiconDialogMutation.graphql.ts";
 import "../components/LexiconTree.tsx"; // Import for fragment
 
···
   sliceUri: string;
   existingNsids: string[];
 }
+
+type SourceType = 'published' | 'new' | null;
 
 export function CreateLexiconDialog({
   open,
···
   sliceUri,
   existingNsids,
 }: CreateLexiconDialogProps) {
+  const [step, setStep] = useState<1 | 2>(1);
+  const [sourceType, setSourceType] = useState<SourceType>(null);
   const [lexiconJson, setLexiconJson] = useState("");
   const [error, setError] = useState("");
   const [isValidating, setIsValidating] = useState(false);
···
     if (isValidating) {
       return; // Prevent closing while validation is in progress
     }
+    setStep(1);
+    setSourceType(null);
     setLexiconJson("");
     setError("");
     setIsValidating(false);
     onClose();
   };
 
+  const handleSourceSelect = (type: SourceType) => {
+    setSourceType(type);
+    setStep(2);
+    setError("");
+  };
+
+  const handleBack = () => {
+    setStep(1);
+    setSourceType(null);
+    setLexiconJson("");
+    setError("");
+  };
+
   return (
     <Dialog
       open={open}
       onClose={handleClose}
-      title="Add Lexicon Definition"
+      title={step === 1 ? "Add Lexicon Definition" : sourceType === 'published' ? "Select Published Lexicon" : "Create New Lexicon"}
       maxWidth="xl"
     >
       {error && (
···
         </div>
       )}
 
-      <form className="space-y-4">
-        <FormControl label="Lexicon JSON">
-          <Textarea
-            value={lexiconJson}
-            onChange={(e) => setLexiconJson(e.target.value)}
-            rows={16}
-            className="font-mono"
-            placeholder={`{
+      {step === 1 ? (
+        <div className="space-y-4">
+          <p className="text-sm text-zinc-400 mb-4">
+            Choose how you'd like to add a lexicon:
+          </p>
+
+          <div className="space-y-3">
+            <button
+              type="button"
+              onClick={() => handleSourceSelect('published')}
+              className="w-full text-left p-4 bg-zinc-900/50 hover:bg-zinc-800/50 border border-zinc-800 hover:border-zinc-700 rounded transition-colors"
+            >
+              <h3 className="text-sm font-medium text-zinc-200 mb-1">
+                Add from Published Lexicons
+              </h3>
+              <p className="text-xs text-zinc-500">
+                Browse and select from community-published AT Protocol lexicons
+              </p>
+            </button>
+
+            <button
+              type="button"
+              onClick={() => handleSourceSelect('new')}
+              className="w-full text-left p-4 bg-zinc-900/50 hover:bg-zinc-800/50 border border-zinc-800 hover:border-zinc-700 rounded transition-colors"
+            >
+              <h3 className="text-sm font-medium text-zinc-200 mb-1">
+                Create New Lexicon
+              </h3>
+              <p className="text-xs text-zinc-500">
+                Write a custom lexicon definition from scratch
+              </p>
+            </button>
+          </div>
+
+          <div className="flex justify-end gap-3 pt-4">
+            <Button
+              type="button"
+              variant="default"
+              onClick={handleClose}
+            >
+              Cancel
+            </Button>
+          </div>
+        </div>
+      ) : sourceType === 'new' ? (
+        <form className="space-y-4">
+          <FormControl label="Lexicon JSON">
+            <Textarea
+              value={lexiconJson}
+              onChange={(e) => setLexiconJson(e.target.value)}
+              rows={16}
+              className="font-mono"
+              placeholder={`{
   "lexicon": 1,
   "id": "network.slices.example",
   "description": "Example record type",
···
     }
   }
 }`}
-            disabled={isMutationInFlight}
-          />
-          <p className="mt-1 text-xs text-zinc-500">
-            Paste a valid AT Protocol lexicon definition in JSON format
-          </p>
-        </FormControl>
+              disabled={isMutationInFlight}
+            />
+            <p className="mt-1 text-xs text-zinc-500">
+              Paste a valid AT Protocol lexicon definition in JSON format
+            </p>
+          </FormControl>
+
+          <div className="flex justify-between gap-3 pt-4">
+            <Button
+              type="button"
+              variant="default"
+              onClick={handleBack}
+              disabled={isMutationInFlight}
+            >
+              Back
+            </Button>
+            <div className="flex gap-3">
+              <Button
+                type="button"
+                variant="default"
+                onClick={handleClose}
+                disabled={isMutationInFlight}
+              >
+                Cancel
+              </Button>
+              <Button
+                type="button"
+                variant="primary"
+                onClick={(e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+                  handleSubmit(e);
+                }}
+                disabled={isMutationInFlight || isValidating}
+              >
+                {isMutationInFlight ? "Adding..." : "Add Lexicon"}
+              </Button>
+            </div>
+          </div>
+        </form>
+      ) : (
+        <PublishedLexiconsList
+          existingNsids={existingNsids}
+          onSelect={(lexicons) => {
+            // Add all lexicons directly without going to JSON editor
+            lexicons.forEach((lexicon) => {
+              const lexiconData = lexicon.data as Record<string, unknown>;
+              const defs = lexiconData.defs || lexiconData.definitions;
+              const nsid = lexicon.nsid;
+              const definitionsString = JSON.stringify(defs);
 
-        <div className="flex justify-end gap-3 pt-4">
-          <Button
-            type="button"
-            variant="default"
-            onClick={handleClose}
-            disabled={isMutationInFlight}
-          >
-            Cancel
-          </Button>
-          <Button
-            type="button"
-            variant="primary"
-            onClick={(e) => {
-              e.preventDefault();
-              e.stopPropagation();
-              handleSubmit(e);
-            }}
-            disabled={isMutationInFlight || isValidating}
-          >
-            {isMutationInFlight ? "Adding..." : "Add Lexicon"}
-          </Button>
-        </div>
-      </form>
+              commitMutation({
+                variables: {
+                  input: {
+                    nsid,
+                    description: (lexiconData.description as string) || "",
+                    definitions: definitionsString,
+                    slice: sliceUri,
+                    createdAt: new Date().toISOString(),
+                    excludedFromSync: false,
+                  },
+                },
+                onCompleted: () => {
+                  // Only close dialog after all mutations complete
+                  // (This will be called for each lexicon)
+                },
+                onError: (err) => {
+                  setError(err.message || "Failed to create lexicon");
+                },
+                updater: (store) => {
+                  const newLexicon = store.getRootField("createNetworkSlicesLexicon");
+                  if (!newLexicon) return;
+
+                  // Extract the rkey from the slice URI (e.g., "at://did/collection/rkey" -> "rkey")
+                  const sliceRkey = sliceUri.split("/").pop();
+                  if (!sliceRkey) return;
+
+                  // Use ConnectionHandler to get the connection
+                  const root = store.getRoot();
+                  const connection = ConnectionHandler.getConnection(
+                    root,
+                    "SliceOverview_networkSlicesLexicons",
+                    {
+                      where: {
+                        slice: { contains: sliceRkey }
+                      }
+                    }
+                  );
+
+                  if (connection) {
+                    // Create and insert a new edge
+                    const newEdge = ConnectionHandler.createEdge(
+                      store,
+                      connection,
+                      newLexicon,
+                      "NetworkSlicesLexiconEdge"
+                    );
+                    ConnectionHandler.insertEdgeAfter(connection, newEdge);
+                  }
+                },
+              });
+            });
+
+            // Close dialog after submitting all mutations
+            handleClose();
+          }}
+          onBack={handleBack}
+          onCancel={handleClose}
+        />
+      )}
     </Dialog>
   );
 }

frontend-v2/src/components/LexiconDependencyConfirmationDialog.tsx

···
+import { Dialog } from "./Dialog.tsx";
+import { Button } from "./Button.tsx";
+
+interface LexiconDependencyConfirmationDialogProps {
+  open: boolean;
+  mainLexiconNsid: string;
+  dependencies: string[];
+  onConfirm: () => void;
+  onCancel: () => void;
+}
+
+export function LexiconDependencyConfirmationDialog({
+  open,
+  mainLexiconNsid,
+  dependencies,
+  onConfirm,
+  onCancel,
+}: LexiconDependencyConfirmationDialogProps) {
+  const totalCount = 1 + dependencies.length;
+
+  return (
+    <Dialog
+      open={open}
+      onClose={onCancel}
+      title="Add Lexicon with Dependencies"
+      maxWidth="md"
+    >
+      <div className="space-y-4">
+        <p className="text-sm text-zinc-400">
+          This lexicon requires {dependencies.length} {dependencies.length === 1 ? "dependency" : "dependencies"}.
+          All {totalCount} lexicons will be added to your slice.
+        </p>
+
+        <div className="space-y-3">
+          <div>
+            <h3 className="text-xs font-medium text-zinc-500 uppercase tracking-wider mb-2">
+              Selected Lexicon
+            </h3>
+            <div className="font-mono text-sm text-zinc-200">
+              {mainLexiconNsid}
+            </div>
+          </div>
+
+          {dependencies.length > 0 && (
+            <div>
+              <h3 className="text-xs font-medium text-zinc-500 uppercase tracking-wider mb-2">
+                Dependencies ({dependencies.length})
+              </h3>
+              <div className="space-y-1">
+                {dependencies.map((nsid) => (
+                  <div
+                    key={nsid}
+                    className="font-mono text-sm text-zinc-400 pl-4"
+                  >
+                    {nsid}
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+        </div>
+
+        <div className="flex justify-end gap-3 pt-4">
+          <Button type="button" variant="default" onClick={onCancel}>
+            Cancel
+          </Button>
+          <Button type="button" variant="primary" onClick={onConfirm}>
+            Add All ({totalCount})
+          </Button>
+        </div>
+      </div>
+    </Dialog>
+  );
+}

frontend-v2/src/components/PublishedLexiconsList.tsx

···
+import { useState } from "react";
+import { graphql, useLazyLoadQuery } from "react-relay";
+import { FormControl } from "./FormControl.tsx";
+import { Input } from "./Input.tsx";
+import { Button } from "./Button.tsx";
+import { LexiconDependencyConfirmationDialog } from "./LexiconDependencyConfirmationDialog.tsx";
+import { resolveDependencies } from "../utils/lexiconDependencies.ts";
+import type { PublishedLexiconsListQuery } from "../__generated__/PublishedLexiconsListQuery.graphql.ts";
+
+interface PublishedLexicon {
+  uri: string;
+  nsid: string;
+  description?: string;
+  defs: unknown;
+  fullData: unknown;
+}
+
+interface LexiconWithData {
+  nsid: string;
+  data: unknown;
+}
+
+interface PublishedLexiconsListProps {
+  existingNsids: string[];
+  onSelect: (lexicons: LexiconWithData[]) => void;
+  onBack: () => void;
+  onCancel: () => void;
+}
+
+const PUBLISHED_LEXICONS_SLICE_URI = "at://did:plc:dzmqinfp7efnofbqg5npjmth/network.slices.slice/3m3fsrppc3p2h";
+
+export function PublishedLexiconsList({
+  existingNsids,
+  onSelect,
+  onBack,
+  onCancel,
+}: PublishedLexiconsListProps) {
+  const [searchQuery, setSearchQuery] = useState("");
+  const [showDepsDialog, setShowDepsDialog] = useState(false);
+  const [selectedLexicon, setSelectedLexicon] = useState<LexiconWithData | null>(null);
+  const [resolvedDeps, setResolvedDeps] = useState<LexiconWithData[]>([]);
+
+  const data = useLazyLoadQuery<PublishedLexiconsListQuery>(
+    graphql`
+      query PublishedLexiconsListQuery(
+        $sliceUri: String!
+        $where: SliceRecordsWhereInput
+      ) {
+        sliceRecords(sliceUri: $sliceUri, first: 1000, where: $where) {
+          edges {
+            node {
+              uri
+              collection
+              value
+            }
+          }
+        }
+      }
+    `,
+    {
+      sliceUri: PUBLISHED_LEXICONS_SLICE_URI,
+      where: {
+        collection: { eq: "com.atproto.lexicon.schema" },
+      },
+    },
+    {
+      fetchPolicy: "store-and-network",
+    }
+  );
+
+  // Parse and filter published lexicons
+  const publishedLexicons = data.sliceRecords.edges
+    .map((edge) => {
+      try {
+        const lexiconData = JSON.parse(edge.node.value);
+        const nsid = lexiconData.id || lexiconData.nsid;
+        const defs = lexiconData.defs || lexiconData.definitions;
+
+        if (!nsid || !defs) return null;
+
+        return {
+          uri: edge.node.uri,
+          nsid,
+          description: lexiconData.description,
+          defs,
+          fullData: lexiconData,
+        } as PublishedLexicon;
+      } catch {
+        return null;
+      }
+    })
+    .filter((lex): lex is PublishedLexicon => lex !== null);
+
+  // Filter by search query
+  const filteredLexicons = publishedLexicons.filter((lex) => {
+    if (!searchQuery) return true;
+    const query = searchQuery.toLowerCase();
+    return (
+      lex.nsid.toLowerCase().includes(query) ||
+      lex.description?.toLowerCase().includes(query)
+    );
+  });
+
+  // Check if lexicon already exists in slice
+  const isAlreadyAdded = (nsid: string) => existingNsids.includes(nsid);
+
+  // Handle lexicon selection with dependency resolution
+  const handleLexiconClick = (lexicon: PublishedLexicon) => {
+    if (isAlreadyAdded(lexicon.nsid)) return;
+
+    // Convert to LexiconWithData format
+    const mainLexicon: LexiconWithData = {
+      nsid: lexicon.nsid,
+      data: lexicon.fullData,
+    };
+
+    // Convert all published lexicons to LexiconWithData format
+    const allLexicons: LexiconWithData[] = publishedLexicons.map(lex => ({
+      nsid: lex.nsid,
+      data: lex.fullData,
+    }));
+
+    // Resolve dependencies
+    const dependencies = resolveDependencies(mainLexicon, allLexicons, existingNsids);
+
+    // If there are dependencies, show confirmation dialog
+    if (dependencies.length > 0) {
+      setSelectedLexicon(mainLexicon);
+      setResolvedDeps(dependencies);
+      setShowDepsDialog(true);
+    } else {
+      // No dependencies, add directly
+      onSelect([mainLexicon]);
+    }
+  };
+
+  // Handle confirmation dialog confirmation
+  const handleConfirmDeps = () => {
+    if (selectedLexicon) {
+      onSelect([selectedLexicon, ...resolvedDeps]);
+    }
+    setShowDepsDialog(false);
+    setSelectedLexicon(null);
+    setResolvedDeps([]);
+  };
+
+  // Handle confirmation dialog cancellation
+  const handleCancelDeps = () => {
+    setShowDepsDialog(false);
+    setSelectedLexicon(null);
+    setResolvedDeps([]);
+  };
+
+  return (
+    <div className="space-y-4">
+      <FormControl label="Search Lexicons" htmlFor="search">
+        <Input
+          id="search"
+          type="text"
+          value={searchQuery}
+          onChange={(e) => setSearchQuery(e.target.value)}
+          placeholder="Filter by NSID or description..."
+        />
+      </FormControl>
+
+      <div className="h-96 overflow-y-auto">
+        {filteredLexicons.length === 0 ? (
+          <div className="text-center py-8 text-sm text-zinc-500">
+            {searchQuery ? "No lexicons match your search" : "No published lexicons found"}
+          </div>
+        ) : (
+          filteredLexicons.map((lexicon) => {
+            const alreadyAdded = isAlreadyAdded(lexicon.nsid);
+            const parts = lexicon.nsid.split(".");
+            const authority = parts.length >= 2 ? `${parts[0]}.${parts[1]}` : parts[0];
+            const rest = parts.length >= 2 ? parts.slice(2).join(".") : "";
+
+            // Check if this is a record type lexicon
+            let isRecordType = false;
+            try {
+              const defs = lexicon.defs as Record<string, { type?: string }> | undefined;
+              isRecordType = defs?.main?.type === "record";
+            } catch {
+              // ignore
+            }
+
+            // Split the rest into middle and last part if it's a record type
+            let middle = rest;
+            let lastPart = "";
+            if (isRecordType && rest) {
+              const restParts = rest.split(".");
+              if (restParts.length > 1) {
+                lastPart = restParts[restParts.length - 1];
+                middle = restParts.slice(0, -1).join(".");
+              } else {
+                lastPart = rest;
+                middle = "";
+              }
+            }
+
+            return (
+              <button
+                key={lexicon.uri}
+                type="button"
+                onClick={() => handleLexiconClick(lexicon)}
+                disabled={alreadyAdded}
+                className={`w-full text-left py-1 rounded group transition-colors ${
+                  alreadyAdded
+                    ? "opacity-50 cursor-not-allowed"
+                    : "hover:bg-zinc-900/50 cursor-pointer"
+                }`}
+              >
+                <div className="flex items-center gap-2">
+                  <span className="text-sm font-medium font-mono">
+                    <span className="text-zinc-200">{authority}</span>
+                    {isRecordType ? (
+                      <>
+                        {middle && <span className="text-zinc-400">.{middle}</span>}
+                        {lastPart && (
+                          <>
+                            <span className="text-zinc-400">.</span>
+                            <span className="text-cyan-400">{lastPart}</span>
+                          </>
+                        )}
+                      </>
+                    ) : (
+                      rest && <span className="text-zinc-400">.{rest}</span>
+                    )}
+                  </span>
+                  {alreadyAdded && (
+                    <span className="text-xs text-zinc-600">
+                      (added)
+                    </span>
+                  )}
+                  {lexicon.description && (
+                    <span className="text-xs text-zinc-600 truncate">
+                      {lexicon.description}
+                    </span>
+                  )}
+                </div>
+              </button>
+            );
+          })
+        )}
+      </div>
+
+      <div className="flex justify-between gap-3 pt-4">
+        <Button type="button" variant="default" onClick={onBack}>
+          Back
+        </Button>
+        <Button type="button" variant="default" onClick={onCancel}>
+          Cancel
+        </Button>
+      </div>
+
+      {/* Dependency confirmation dialog */}
+      <LexiconDependencyConfirmationDialog
+        open={showDepsDialog}
+        mainLexiconNsid={selectedLexicon?.nsid || ""}
+        dependencies={resolvedDeps.map(dep => dep.nsid)}
+        onConfirm={handleConfirmDeps}
+        onCancel={handleCancelDeps}
+      />
+    </div>
+  );
+}

frontend-v2/src/generateChartData.ts

···
 }
 
 export function generateChartData(
-  plays: readonly { readonly playedTime?: string | null; readonly [key: string]: any }[],
-  days = 90
+  plays: readonly {
+    readonly playedTime?: string | null;
+    readonly [key: string]: unknown;
+  }[],
+  days = 90,
 ): DataPoint[] {
   const counts = new Map<string, number>();
   const now = new Date();

frontend-v2/src/utils/lexiconDependencies.ts

···
+/**
+ * Extracts all external lexicon references from a lexicon's defs
+ * Returns unique NSIDs (without #defName fragments)
+ */
+export function extractExternalRefs(defs: unknown): string[] {
+  const refs = new Set<string>();
+
+  function traverse(obj: unknown): void {
+    if (Array.isArray(obj)) {
+      obj.forEach(traverse);
+    } else if (obj !== null && typeof obj === "object") {
+      const objRecord = obj as Record<string, unknown>;
+
+      // Check if this is a ref object (single ref)
+      if (objRecord.type === "ref" && typeof objRecord.ref === "string") {
+        const ref = objRecord.ref;
+
+        // Only include external refs (not starting with #)
+        if (!ref.startsWith("#")) {
+          // Strip #defName suffix if present
+          const nsid = ref.split("#")[0];
+          refs.add(nsid);
+        }
+      }
+
+      // Check if this is a union type with multiple refs
+      if (objRecord.type === "union" && Array.isArray(objRecord.refs)) {
+        for (const ref of objRecord.refs) {
+          if (typeof ref === "string" && !ref.startsWith("#")) {
+            // Strip #defName suffix if present
+            const nsid = ref.split("#")[0];
+            refs.add(nsid);
+          }
+        }
+      }
+
+      // Recursively traverse all properties
+      for (const value of Object.values(objRecord)) {
+        traverse(value);
+      }
+    }
+  }
+
+  traverse(defs);
+  return Array.from(refs);
+}
+
+interface LexiconWithData {
+  nsid: string;
+  data: unknown;
+}
+
+/**
+ * Resolves all transitive dependencies for a lexicon
+ * Uses BFS to find all required lexicons, avoiding circular references
+ */
+export function resolveDependencies(
+  mainLexicon: LexiconWithData,
+  allAvailableLexicons: LexiconWithData[],
+  existingNsids: string[]
+): LexiconWithData[] {
+  const dependencies: LexiconWithData[] = [];
+  const visited = new Set<string>();
+  const queue: LexiconWithData[] = [mainLexicon];
+
+  // Create a map for quick lookups
+  const lexiconMap = new Map<string, LexiconWithData>();
+  for (const lex of allAvailableLexicons) {
+    lexiconMap.set(lex.nsid, lex);
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+
+    // Skip if already visited or already in user's slice
+    if (visited.has(current.nsid) || existingNsids.includes(current.nsid)) {
+      continue;
+    }
+
+    visited.add(current.nsid);
+
+    // Add to dependencies (except for the main lexicon)
+    if (current.nsid !== mainLexicon.nsid) {
+      dependencies.push(current);
+    }
+
+    // Extract refs from this lexicon's defs
+    try {
+      const lexData = current.data as Record<string, unknown>;
+      const defs = lexData.defs || lexData.definitions;
+      const refs = extractExternalRefs(defs);
+
+      // Queue up any dependencies we haven't visited yet
+      for (const refNsid of refs) {
+        if (!visited.has(refNsid) && lexiconMap.has(refNsid)) {
+          queue.push(lexiconMap.get(refNsid)!);
+        }
+      }
+    } catch {
+      // If we can't parse the lexicon, skip it
+      continue;
+    }
+  }
+
+  return dependencies;
+}