test(vnext): harden integrated completion paths

Author: Light2Dark

src/vnext/__tests__/session.test.ts

@@ -1570,6 +1570,56 @@ describe("namespace completion session integration", () => {
       vi.useRealTimers();
     }
   });
+
+  it("supports a namespace-only service and preserves partial evidence", async () => {
+    const service = createSqlLanguageService<TestContext>({
+      dialects: [duckdb],
+      namespaces: {
+        id: "namespace-only",
+        search: async () => ({
+          containers: [{
+            canonicalPath: [{
+              quoted: false,
+              role: "schema",
+              value: "main",
+            }],
+            containerEntityId: "schema:main",
+            insertText: "main",
+            matchQuality: "equivalent",
+          }],
+          coverage: "partial",
+          epoch: { generation: 1, token: "epoch-1" },
+          status: "ready",
+        }),
+      },
+    });
+    const text = "SELECT * FROM m";
+    const session = service.openDocument({
+      context: {
+        catalog: { scope: "connection:namespace-only" },
+        dialect: "duckdb",
+        engine: "local",
+      },
+      text,
+    });
+
+    await expect(session.complete({
+      position: text.length,
+      trigger: { kind: "invoked" },
+    })).resolves.toMatchObject({
+      sources: [{
+        coverage: "partial",
+        feature: "namespace-catalog",
+      }],
+      status: "ready",
+      value: {
+        isIncomplete: true,
+        issues: [{ reason: "namespace-catalog-partial" }],
+        items: [{ kind: "namespace", label: "main" }],
+      },
+    });
+    service.dispose();
+  });
 });
 
 describe("statement-index session cache", () => {
@@ -3883,6 +3933,18 @@ describe("session coverage hardening", () => {
     });
   });
 
+  it.each([
+    { columns: { id: "", loadColumns: async () => ({}) } },
+    { namespaces: { id: "", search: async () => ({}) } },
+  ])("rejects a malformed auxiliary provider %#", (provider) => {
+    expectSessionError("invalid-service-options", () => {
+      createSqlLanguageService({
+        ...provider,
+        dialects: [duckdb],
+      });
+    });
+  });
+
   it.each([
     {
       expectedIssue: "catalog-failed",

src/vnext/codemirror/__tests__/sql-editor.test.ts

@@ -1096,6 +1096,32 @@ describe("sqlEditor", () => {
     expect(harness.sessionDisposals()).toBe(0);
   });
 
+  it("refuses a completion edit that overlaps an embedded region", async () => {
+    const harness = fakeService((revision) =>
+      readyResult(revision, [completionItem(14, 16)])
+    );
+    const support = sqlEditor({
+      initialContext: context(),
+      initialEmbeddedRegions: [{
+        from: 15,
+        language: "host",
+        to: 16,
+      }],
+      service: harness.service,
+    });
+    const view = createView(support.extension);
+    expect(startCompletion(view)).toBe(true);
+    await waitForActiveCompletion(view);
+    const completion = currentCompletions(view.state)[0];
+    if (!completion || typeof completion.apply !== "function") {
+      throw new Error("Expected completion apply callback");
+    }
+
+    completion.apply(view, completion, 14, 16);
+    expect(view.state.doc.toString()).toBe("SELECT * FROM us");
+    expect(harness.updates).toEqual([]);
+  });
+
   it("combines document and final context effects into one current input", async () => {
     const requests: SqlCatalogSearchRequest[] = [];
     const service = createSqlLanguageService<TestContext>({
@@ -1275,6 +1301,59 @@ describe("sqlEditor", () => {
     );
   });
 
+  it("maps column and namespace completion presentation", async () => {
+    const epoch = { generation: 1, token: "epoch-1" };
+    const items: readonly SqlCompletionItem[] = [{
+      edit: { from: 14, insert: "users_column", to: 16 },
+      kind: "column",
+      label: "users_column",
+      provenance: {
+        columnEntityId: "users:name",
+        epoch,
+        kind: "column-catalog",
+        providerId: "columns",
+        relationEntityId: "users",
+        scope: "connection:fake",
+      },
+      relationRequestKey: "binding:0",
+    }, {
+      edit: { from: 14, insert: "users_namespace", to: 16 },
+      kind: "namespace",
+      label: "users_namespace",
+      provenance: {
+        containerEntityId: "schema:main",
+        epoch,
+        kind: "namespace-catalog",
+        providerId: "namespaces",
+        scope: "connection:fake",
+      },
+      role: "schema",
+    }];
+    const harness = fakeService((revision) =>
+      readyResult(revision, items)
+    );
+    const support = sqlEditor({
+      initialContext: context(),
+      service: harness.service,
+    });
+    const view = createView(support.extension);
+
+    expect(startCompletion(view)).toBe(true);
+    await waitForActiveCompletion(view);
+    expect(currentCompletions(view.state)).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          label: "users_column",
+          type: "property",
+        }),
+        expect.objectContaining({
+          label: "users_namespace",
+          type: "namespace",
+        }),
+      ]),
+    );
+  });
+
   it("denies SQL completion at an unmatched template EOF without removing external sources", async () => {
     const harness = fakeService((revision) =>
       readyResult(revision, [completionItem()])