feat(vnext): integrate namespace completion

Author: Light2Dark

docs/vnext/marimo-sql-migration.md

@@ -1,6 +1,6 @@
 # Marimo SQL Completion Migration
 
-Status: implementation fixture; relation and column completion
+Status: implementation fixture; relation, column, and namespace completion
 
 The compile-only fixture
 [`marimo-sql-migration.test-d.ts`](../../test/vnext-types/marimo-sql-migration.test-d.ts)
@@ -121,20 +121,17 @@ explicit, tested generic-dialect policy.
 
 Marimo's current `tablesCompletionSource()` is broader than its name. The
 CodeMirror SQL schema source provides relations, namespace navigation, and
-columns. vNext now provides the relation and lazy batched column portions,
+columns. vNext now provides all three through separate bounded providers,
 including qualified and unqualified query-site completion, ambiguity handling,
-stable provenance, cancellation, and bounded provider work.
+stable provenance, cancellation, and batched column work.
 
 The remaining feature gaps are:
 
-- namespace/container completion for database, schema, project, and dataset
-  navigation; and
 - the dialect coverage described above.
 
-The fixture defines marimo's immutable namespace projection—stable entity ID,
-scope, canonical identifier path, and namespace kind—but deliberately does
-not invent a provider import. Once a public namespace provider lands, that
-projection should feed one scoped provider on the shared service.
+The fixture feeds marimo's immutable namespace projection—stable entity ID,
+scope, canonical identifier path, and namespace kind—through one public,
+scoped namespace provider on the shared service.
 
 ## Migration sequence
 
@@ -148,20 +145,18 @@ projection should feed one scoped provider on the shared service.
 4. Compare relation and column results with the golden corpus, including
    quoted insert text, aliases, ambiguity, partial/loading/failure states, and
    cold epoch behavior.
-5. Add the public namespace provider and connect the prepared marimo namespace
-   projection.
-6. Cut over the four supported dialects as one source replacement, preserving
+5. Cut over the four supported dialects as one source replacement, preserving
    variable and keyword external sources.
-7. Add dialect coverage, expand the router, and remove completion-only legacy
+6. Add dialect coverage, expand the router, and remove completion-only legacy
    schema code. Keep legacy schema data while hover or diagnostics still use
    it.
 
 ## Acceptance tests
 
 The compile-only marimo fixture proves:
 
-- one shared service configured with one relation provider and one batched
-  column provider;
+- one shared service configured with one relation provider, one batched
+  column provider, and one namespace provider;
 - a two-relation cold column request with `expectedEpoch: null`;
 - stable relation and column IDs, canonical identifiers, and distinct
   provider-rendered insert text;

docs/vnext/namespace-catalog-authority.md

@@ -1,6 +1,6 @@
 # vNext Namespace Catalog Authority
 
-Status: integration-ready internal vertical slice
+Status: public provider and session integration
 
 Namespace completion searches catalog, schema, project, and dataset containers.
 One query site produces one bounded provider request containing its qualifier,
@@ -30,8 +30,9 @@ A newer request supersedes and aborts prior work for the same owner. Explicit
 cancellation and owner/coordinator disposal abort pending work. Provider throws,
 rejections, malformed data, and late settlements are contained.
 
-Session integration should prepare one owner for each live scope/dialect and
-dispose it when catalog authority changes. Query-site integration calls
+Session integration prepares one owner for each live scope/dialect and
+disposes it when catalog authority changes. Query-site integration calls
 `prepareSqlNamespaceCatalogSearch`, submits the result through the owner, and
 passes the outcome plus the site's replacement range and dialect prefix matcher
-to `composeSqlNamespaceCompletion`.
+to `composeSqlNamespaceCompletion`. Namespace items are merged with local and
+relation-catalog items under the same bounded completion response budget.

src/vnext/__tests__/session.test.ts

@@ -7,6 +7,7 @@ import {
   postgresDialect,
   SqlSessionError,
   type SqlColumnCatalogProvider,
+  type SqlNamespaceCatalogProvider,
 } from "../index.js";
 import {
   DefaultSqlLanguageService,
@@ -1428,6 +1429,149 @@ describe("column completion session integration", () => {
   });
 });
 
+describe("namespace completion session integration", () => {
+  const relationCatalog: SqlRelationCatalogProvider = {
+    id: "relations",
+    search: async () => ({
+      coverage: { kind: "complete" },
+      epoch: { generation: 1, token: "epoch-1" },
+      relations: [],
+      status: "ready",
+    }),
+  };
+
+  function serviceWithNamespaces(
+    search: SqlNamespaceCatalogProvider["search"],
+    budget = 40,
+  ) {
+    return createSqlLanguageService<TestContext>({
+      catalog: relationCatalog,
+      completion: { catalogResponseBudgetMs: budget },
+      dialects: [duckdb],
+      namespaces: { id: "namespaces", search },
+    });
+  }
+
+  it("merges namespace containers into relation-site completion", async () => {
+    const requests: Parameters<
+      SqlNamespaceCatalogProvider["search"]
+    >[0][] = [];
+    const service = serviceWithNamespaces(async (request) => {
+      requests.push(request);
+      return {
+        containers: [{
+          canonicalPath: [{
+            quoted: false,
+            role: "schema",
+            value: "main",
+          }],
+          containerEntityId: "schema:main",
+          detail: "DuckDB schema",
+          insertText: "main",
+          matchQuality: "exact",
+        }],
+        coverage: "complete",
+        epoch: { generation: 1, token: "epoch-1" },
+        status: "ready",
+      };
+    });
+    const text = "SELECT * FROM ma";
+    const session = service.openDocument({
+      context: {
+        catalog: {
+          scope: "connection:1",
+          searchPath: [[{ quoted: false, value: "main" }]],
+        },
+        dialect: "duckdb",
+        engine: "local",
+      },
+      text,
+    });
+
+    await expect(session.complete({
+      position: text.length,
+      trigger: { kind: "invoked" },
+    })).resolves.toMatchObject({
+      sources: [
+        { feature: "relation-catalog" },
+        {
+          feature: "namespace-catalog",
+          outcome: "ready",
+          providerId: "namespaces",
+        },
+      ],
+      status: "ready",
+      value: {
+        isIncomplete: false,
+        items: [{
+          detail: "DuckDB schema",
+          edit: { from: 14, insert: "main", to: 16 },
+          kind: "namespace",
+          label: "main",
+          provenance: {
+            containerEntityId: "schema:main",
+            kind: "namespace-catalog",
+            providerId: "namespaces",
+            scope: "connection:1",
+          },
+          role: "schema",
+        }],
+      },
+    });
+    expect(requests).toHaveLength(1);
+    expect(requests[0]).toMatchObject({
+      dialectId: "duckdb",
+      expectedEpoch: null,
+      limit: 128,
+      prefix: { quoted: false, value: "ma" },
+      qualifier: [],
+      scope: "connection:1",
+    });
+    service.dispose();
+  });
+
+  it("keeps slow namespace providers inside the shared budget", async () => {
+    vi.useFakeTimers();
+    try {
+      const service = serviceWithNamespaces(
+        () => new Promise(() => {}),
+        0,
+      );
+      const text = "SELECT * FROM ";
+      const session = service.openDocument({
+        context: {
+          catalog: { scope: "connection:1" },
+          dialect: "duckdb",
+          engine: "local",
+        },
+        text,
+      });
+      const completion = session.complete({
+        position: text.length,
+        trigger: { kind: "invoked" },
+      });
+      await vi.advanceTimersByTimeAsync(0);
+      await expect(completion).resolves.toMatchObject({
+        sources: [
+          { feature: "relation-catalog" },
+          {
+            feature: "namespace-catalog",
+            outcome: "loading",
+          },
+        ],
+        status: "ready",
+        value: {
+          isIncomplete: true,
+          issues: [{ reason: "namespace-catalog-loading" }],
+        },
+      });
+      service.dispose();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
+
 describe("statement-index session cache", () => {
   it("binds lexical behavior through authentic dialect handles", () => {
     const service = new DefaultSqlLanguageService<TestContext>({

src/vnext/codemirror/browser_tests/sql-editor-completion-gate.test.ts

@@ -218,3 +218,60 @@ test("vNext editor applies a batched column completion", async () => {
   service.dispose();
   parent.remove();
 });
+
+test("vNext editor exposes namespace containers at relation sites", async () => {
+  const parent = document.createElement("div");
+  document.body.append(parent);
+  let namespaceCalls = 0;
+  const service = createSqlLanguageService({
+    dialects: [duckdbDialect()],
+    namespaces: {
+      id: "browser-namespaces",
+      search: async () => {
+        namespaceCalls += 1;
+        return {
+          containers: [{
+            canonicalPath: [{
+              quoted: false,
+              role: "schema",
+              value: "main",
+            }],
+            containerEntityId: "schema:main",
+            insertText: "main",
+            matchQuality: "exact",
+          }],
+          coverage: "complete",
+          epoch: { generation: 1, token: "epoch-1" },
+          status: "ready",
+        };
+      },
+    },
+  });
+  const support = sqlEditor({
+    initialContext: {
+      catalog: { scope: "browser-namespaces" },
+      dialect: "duckdb",
+    },
+    service,
+  });
+  const documentText = "SELECT * FROM ma";
+  const view = new EditorView({
+    doc: documentText,
+    extensions: support.extension,
+    parent,
+    selection: { anchor: documentText.length },
+  });
+
+  expect(startCompletion(view)).toBe(true);
+  await expect.poll(() =>
+    currentCompletions(view.state).map((item) => ({
+      label: item.label,
+      type: item.type,
+    }))
+  ).toEqual([{ label: "main", type: "namespace" }]);
+  expect(namespaceCalls).toBe(1);
+
+  view.destroy();
+  service.dispose();
+  parent.remove();
+});

src/vnext/codemirror/sql-editor.ts

@@ -204,6 +204,7 @@ function haveOneEditRange(items: readonly SqlCompletionItem[]): boolean {
 
 function completionType(item: SqlCompletionItem): string {
   if (item.kind === "column") return "property";
+  if (item.kind === "namespace") return "namespace";
   return item.relationKind === "cte" ? "type" : "table";
 }
 

src/vnext/index.ts

@@ -16,6 +16,18 @@ export type {
   SqlColumnCatalogRelationResult,
   SqlColumnCatalogResolvedColumn,
 } from "./column-catalog-types.js";
+export type {
+  SqlCanonicalNamespacePath,
+  SqlNamespaceCatalogContainer,
+  SqlNamespaceCatalogProvider,
+  SqlNamespaceCatalogProvenance,
+  SqlNamespaceCatalogResolvedContainer,
+  SqlNamespaceCatalogSearchRequest,
+  SqlNamespaceCatalogSearchResponse,
+  SqlNamespaceContainerRole,
+  SqlNamespacePathComponent,
+  SqlNamespaceQuerySite,
+} from "./namespace-catalog-types.js";
 export type {
   OpenSqlDocument,
   SqlCatalogContext,
@@ -70,6 +82,8 @@ export type {
   SqlCompletionIssue,
   SqlCompletionRequest,
   SqlCompletionRefreshToken,
+  SqlNamespaceCatalogProviderReport,
+  SqlNamespaceCompletionProvenance,
   SqlCompletionTrigger,
   SqlDisposable,
   SqlRelationCatalogProvider,