Use new typed RDF literals instead of resolveLanguage: literal where it makes sense

app/src/utils/__tests__/routeUtils.test.ts

@@ -0,0 +1,94 @@
+import {
+  stripNeighbourhoodPrefix,
+  restoreNeighbourhoodPrefix,
+  stripChannelPrefix,
+  restoreChannelPrefix,
+} from '../routeUtils';
+
+describe('stripNeighbourhoodPrefix', () => {
+  it('strips neighbourhood:// prefix', () => {
+    expect(stripNeighbourhoodPrefix('neighbourhood://abc123')).toBe('abc123');
+  });
+
+  it('strips private:// prefix', () => {
+    expect(stripNeighbourhoodPrefix('private://abc123')).toBe('abc123');
+  });
+
+  it('returns bare strings unchanged', () => {
+    expect(stripNeighbourhoodPrefix('abc123')).toBe('abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(stripNeighbourhoodPrefix(undefined as unknown as string)).toBe('');
+    expect(stripNeighbourhoodPrefix('')).toBe('');
+  });
+});
+
+describe('restoreNeighbourhoodPrefix', () => {
+  it('prepends neighbourhood:// to bare IDs', () => {
+    expect(restoreNeighbourhoodPrefix('abc123')).toBe('neighbourhood://abc123');
+  });
+
+  it('passes through neighbourhood:// IDs unchanged', () => {
+    expect(restoreNeighbourhoodPrefix('neighbourhood://abc123')).toBe('neighbourhood://abc123');
+  });
+
+  it('passes through private:// IDs unchanged', () => {
+    expect(restoreNeighbourhoodPrefix('private://abc123')).toBe('private://abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(restoreNeighbourhoodPrefix(undefined as unknown as string)).toBe('');
+    expect(restoreNeighbourhoodPrefix('')).toBe('');
+  });
+});
+
+describe('stripChannelPrefix', () => {
+  it('strips literal:string: prefix', () => {
+    expect(stripChannelPrefix('literal:string:abc123')).toBe('abc123');
+  });
+
+  it('passes through ad4m://obj/ IDs unchanged', () => {
+    expect(stripChannelPrefix('ad4m://obj/abc123')).toBe('ad4m://obj/abc123');
+  });
+
+  it('passes through bare strings unchanged', () => {
+    expect(stripChannelPrefix('abc123')).toBe('abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(stripChannelPrefix(undefined as unknown as string)).toBe('');
+    expect(stripChannelPrefix('')).toBe('');
+  });
+});
+
+describe('restoreChannelPrefix', () => {
+  it('prepends literal:string: to bare IDs', () => {
+    expect(restoreChannelPrefix('abc123')).toBe('literal:string:abc123');
+  });
+
+  it('passes through ad4m://obj/ IDs unchanged', () => {
+    expect(restoreChannelPrefix('ad4m://obj/abc123')).toBe('ad4m://obj/abc123');
+  });
+
+  it('passes through any :// scheme unchanged', () => {
+    expect(restoreChannelPrefix('neighbourhood://abc123')).toBe('neighbourhood://abc123');
+  });
+
+  it('returns empty string for undefined/empty input', () => {
+    expect(restoreChannelPrefix(undefined as unknown as string)).toBe('');
+    expect(restoreChannelPrefix('')).toBe('');
+  });
+});
+
+describe('round-trip: stripChannelPrefix → restoreChannelPrefix', () => {
+  it('round-trips legacy literal:string: IDs', () => {
+    const original = 'literal:string:abc123';
+    expect(restoreChannelPrefix(stripChannelPrefix(original))).toBe(original);
+  });
+
+  it('round-trips ad4m://obj/ IDs', () => {
+    const original = 'ad4m://obj/abc123';
+    expect(restoreChannelPrefix(stripChannelPrefix(original))).toBe(original);
+  });
+});

app/src/utils/routeUtils.ts

@@ -5,6 +5,7 @@
 
 // Strips neighbourhood URL prefix to get clean community ID
 export function stripNeighbourhoodPrefix(neighbourhoodUrl: string): string {
+  if (!neighbourhoodUrl) return '';
   const prefix = 'neighbourhood://';
   const privatePrefix = 'private://';
   if (neighbourhoodUrl.startsWith(prefix)) return neighbourhoodUrl.slice(prefix.length);
@@ -20,13 +21,20 @@ export function restoreNeighbourhoodPrefix(communityId: string): string {
   return `neighbourhood://${communityId}`;
 }
 
-// Strips literal:string: prefix from channel ID
+// Strips the legacy literal:string: prefix from a channel ID for use in route params.
+// New ad4m://obj/ IDs pass through unchanged — they round-trip via restoreChannelPrefix
+// which detects the :// scheme and returns them as-is.
 export function stripChannelPrefix(channelId: string): string {
+  if (!channelId) return '';
   if (channelId.startsWith('literal:string:')) return channelId.slice('literal:string:'.length);
   return channelId;
 }
 
-// Restores literal:string: prefix to channel ID
+// Restores the instance-ID prefix from a clean route param.
+// IDs that already carry a scheme (ad4m://, literal:, neighbourhood://) pass through unchanged.
+// Bare IDs get the legacy literal:string: prefix for backwards compatibility.
 export function restoreChannelPrefix(channelId: string): string {
+  if (!channelId) return '';
+  if (channelId.includes('://')) return channelId;
   return `literal:string:${channelId}`;
 }

app/src/views/main/community/channel/Header.vue

@@ -86,8 +86,9 @@ import { useAppStore, useModalStore, useUiStore, useWebrtcStore } from '@/stores
 import { stripChannelPrefix } from '@/utils/routeUtils';
 import { App, Channel, ChannelSummary } from '@coasys/flux-api';
 import { useLiveQuery } from '@coasys/ad4m-vue-hooks';
+import { fluxDebug, fluxDebugWarn } from '@coasys/flux-utils';
 import { storeToRefs } from 'pinia';
-import { computed, onActivated, onMounted } from 'vue';
+import { computed, onActivated, onMounted, watch } from 'vue';
 import { useRouter } from 'vue-router';
 
 defineOptions({ name: 'Header' });
@@ -124,6 +125,31 @@ const { data: views } = useLiveQuery(App, perspective, {
   parent: { model: Channel, id: channel.value?.id ?? '' },
 });
 
+// Debug: trace every state transition on the channel-view (plugin tabs) query.
+// Symptom we're chasing: on the AD4M typed-RDF-literals branch, the plugin
+// tabs disappear silently — the header renders no <label class="tab"> entries
+// because `views` is empty, and there is no error surfaced to the user. This
+// lets us see whether App.parent=Channel resolution is returning [] and why.
+watch(
+  [() => channel.value?.id, () => views.value?.length ?? -1],
+  ([channelId, count]) => {
+    fluxDebug('ChannelHeader.plugins', 'query.state', {
+      channelId,
+      perspectiveUuid: perspective?.uuid,
+      viewCount: count,
+      firstViewPkg: views.value?.[0]?.pkg,
+      firstViewName: views.value?.[0]?.name,
+    });
+    if (channelId && count === 0) {
+      fluxDebugWarn('ChannelHeader.plugins', 'query.empty', {
+        channelId,
+        hint: 'useLiveQuery(App, parent=Channel) returned no plugin views — check that App @Property/@HasMany resolves through the has_child predicate and the SDNA subject class is loaded.',
+      });
+    }
+  },
+  { immediate: true },
+);
+
 function manageChannelPlugins() {
   modalStore.showManageChannelPluginsModal = true;
 }

app/src/views/main/community/channel/view/ViewView.vue

@@ -90,7 +90,7 @@ async function onViewClick(e: any) {
     if (!url.startsWith('http')) e.preventDefault();
     if (url.startsWith('neighbourhood://')) onNeighbourhoodClick(url);
     if (url.startsWith('did:')) onAgentClick(url);
-    if (url.startsWith('literal:')) {
+    if (url.startsWith('literal:') || url.startsWith('ad4m://obj/')) {
       const isChannel = await perspective.isSubjectInstance(url, Channel);
       if (isChannel) {
         router.push({ name: 'channel', params: { communityId, channelId: stripChannelPrefix(url) } });

app/src/views/main/community/modals/__tests__/createChannelLinks.test.ts

@@ -2,21 +2,31 @@ import { buildChannelParentLink } from '../createChannelLinks';
 
 describe('buildChannelParentLink', () => {
   it('uses flux://has_channel for a nested channel', () => {
-    const link = buildChannelParentLink('literal:string:parent-channel', 'literal:string:new-channel');
+    const link = buildChannelParentLink('ad4m://obj/parent-channel', 'ad4m://obj/new-channel');
 
     expect(link).toMatchObject({
-      source: 'literal:string:parent-channel',
+      source: 'ad4m://obj/parent-channel',
       predicate: 'flux://has_channel',
-      target: 'literal:string:new-channel',
+      target: 'ad4m://obj/new-channel',
     });
   });
 
   it('uses ad4m://self as the top-level source with flux://has_channel', () => {
-    const link = buildChannelParentLink(undefined, 'literal:string:new-channel');
+    const link = buildChannelParentLink(undefined, 'ad4m://obj/new-channel');
 
     expect(link).toMatchObject({
       source: 'ad4m://self',
       predicate: 'flux://has_channel',
+      target: 'ad4m://obj/new-channel',
+    });
+  });
+
+  it('handles legacy literal:string: IDs', () => {
+    const link = buildChannelParentLink('literal:string:parent-channel', 'literal:string:new-channel');
+
+    expect(link).toMatchObject({
+      source: 'literal:string:parent-channel',
+      predicate: 'flux://has_channel',
       target: 'literal:string:new-channel',
     });
   });

packages/api/src/channel/index.ts

@@ -1,7 +1,7 @@
 import { Ad4mModel, HasMany, HasManyMethods, Flag, Literal, LinkQuery, Model, Property, PerspectiveProxy, parseLit, parseSparqlCount, CountBinding } from '@coasys/ad4m';
 import { community } from '@coasys/flux-constants';
 import { EntryType } from '@coasys/flux-types';
-import { SynergyGroup, SynergyItem, ItemType, icons } from '@coasys/flux-utils';
+import { SynergyGroup, SynergyItem, ItemType, icons, fluxDebug, fluxDebugWarn } from '@coasys/flux-utils';
 import App from '../app';
 import Conversation from '../conversation';
 import Message from '../message';
@@ -117,26 +117,50 @@ export class Channel extends Ad4mModel {
 
       const sparqlResult = await this.perspective.querySparql<ChannelItemBinding[]>(sparqlQuery);
 
+      // Debug: log raw SPARQL binding shape. The typed-RDF-literals refactor
+      // in coasys/ad4m#874 changed wire form for scalar values; if body still
+      // arrives as a `literal:string:*` envelope, storage-vs-decode is mismatched.
+      fluxDebug('Channel.allItems', 'sparql.result', {
+        channelId: this.id,
+        rowCount: (sparqlResult || []).length,
+        firstRow: sparqlResult?.[0],
+        types: [...new Set((sparqlResult || []).map((r) => r.type))],
+      });
+      if (sparqlResult?.length) {
+        const envelope = sparqlResult.find((r) => typeof r.body === 'string' && r.body.startsWith('literal:'));
+        if (envelope) {
+          fluxDebugWarn('Channel.allItems', 'sparql.body-is-envelope', {
+            channelId: this.id,
+            sampleBody: envelope.body?.slice(0, 120),
+            hint: 'Message.body arrives as a `literal:*` envelope URI — parseLit() decode is required.',
+          });
+        }
+      }
+
       const mapped = (sparqlResult || []).map((binding) => {
         let text = '';
         let type: ItemType = 'Message';
         const itemType = binding.type;
 
+        // title / taskName / transcriptStart are typed XSD literals — SPARQL
+        // binding returns their lexical form directly, no decode.
+        // Only Message.body is an envelope literal (resolveLanguage: 'literal')
+        // so it still needs parseLit() to unwrap the `.data` field.
         if (itemType === 'flux://has_message') {
           text = parseLit(binding.body);
           type = 'Message';
         } else if (itemType === 'flux://has_post') {
-          text = parseLit(binding.title);
+          text = binding.title ?? '';
           type = 'Post';
         } else if (itemType === 'flux://has_task') {
-          text = parseLit(binding.taskName);
+          text = binding.taskName ?? '';
           type = 'Task';
         }
 
         return {
           id: binding.id,
           author: binding.author,
-          timestamp: new Date(parseLit(binding.transcriptStart) || binding.timestamp).toISOString(),
+          timestamp: new Date(binding.transcriptStart || binding.timestamp).toISOString(),
           text,
           type,
           icon: icons[type] || 'question',
@@ -228,21 +252,23 @@ export class Channel extends Ad4mModel {
         let type: ItemType = 'Message';
         const itemType = binding.type;
 
+        // Only Message.body needs parseLit() (envelope literal). All other
+        // scalar fields are typed XSD literals and used as-is.
         if (itemType === 'flux://has_message') {
           text = parseLit(binding.body);
           type = 'Message';
         } else if (itemType === 'flux://has_post') {
-          text = parseLit(binding.title);
+          text = binding.title ?? '';
           type = 'Post';
         } else if (itemType === 'flux://has_task') {
-          text = parseLit(binding.taskName);
+          text = binding.taskName ?? '';
           type = 'Task';
         }
 
         return {
           id: binding.id,
           author: binding.author,
-          timestamp: new Date(parseLit(binding.transcriptStart) || binding.timestamp).toISOString(),
+          timestamp: new Date(binding.transcriptStart || binding.timestamp).toISOString(),
           text,
           type,
           icon: icons[type] || 'question',
@@ -310,8 +336,9 @@ export class Channel extends Ad4mModel {
       for (const r of results || []) {
         const cid = r.channelId;
         if (!cid || channelMap.has(cid)) continue;
-        const parsed = parseLit(r.isConv);
-        if (String(parsed) !== 'true') continue;
+        // CHANNEL_IS_CONVERSATION is a boolean typed literal; SPARQL binding
+        // returns its lexical form directly.
+        if (r.isConv !== 'true') continue;
         channelMap.set(cid, {
           channelId: cid,
           conversationId: r.conversationId || undefined,

packages/api/src/conversation-subgroup/index.ts

@@ -102,7 +102,8 @@ export default class ConversationSubgroup extends Ad4mModel {
         if (topicBase && !uniqueTopics.has(topicBase)) {
           uniqueTopics.set(topicBase, {
             topicBase,
-            topicName: parseLit(binding.topicNameRaw),
+            // Typed XSD literal — SPARQL binding gives lexical form directly.
+            topicName: binding.topicNameRaw ?? '',
           });
         }
       }
@@ -155,24 +156,27 @@ export default class ConversationSubgroup extends Ad4mModel {
         if (!id) continue;
 
         // Coalesce OPTIONAL fields from multiple SPARQL rows for same id
+        // body/title/taskName/transcriptStart are typed XSD literals; SPARQL
+        // binding returns their lexical form directly, no decode needed.
         if (seen.has(id)) {
           // Merge optional fields from this binding into the existing item
           const existing = seen.get(id)!;
-          const transcriptStart = parseLit(binding.transcriptStart);
+          const transcriptStart = binding.transcriptStart ?? '';
           const channelTs = binding.channelTs;
           const fallbackTs = binding.timestamp;
           if (!existing.channelTimestamp) {
             existing.channelTimestamp = transcriptStart || channelTs || fallbackTs;
           }
+          // Message.body is envelope-encoded (resolveLanguage: 'literal'); decode via parseLit.
           if (!existing.messageBody) existing.messageBody = parseLit(binding.body);
-          if (!existing.postTitle) existing.postTitle = parseLit(binding.title);
-          if (!existing.taskName) existing.taskName = parseLit(binding.taskName);
+          if (!existing.postTitle) existing.postTitle = binding.title ?? '';
+          if (!existing.taskName) existing.taskName = binding.taskName ?? '';
           if (!existing.type) existing.type = binding.type;
           if (!existing.author) existing.author = binding.author;
           continue;
         }
 
-        const transcriptStart = parseLit(binding.transcriptStart);
+        const transcriptStart = binding.transcriptStart ?? '';
         const channelTs = binding.channelTs;
         const fallbackTs = binding.timestamp;
         const channelTimestamp = transcriptStart || channelTs || fallbackTs;
@@ -182,9 +186,10 @@ export default class ConversationSubgroup extends Ad4mModel {
           type: binding.type,
           author: binding.author,
           channelTimestamp,
+          // Message.body is envelope-encoded (resolveLanguage: 'literal'); decode via parseLit.
           messageBody: parseLit(binding.body),
-          postTitle: parseLit(binding.title),
-          taskName: parseLit(binding.taskName),
+          postTitle: binding.title ?? '',
+          taskName: binding.taskName ?? '',
         };
         seen.set(id, item);
         items.push(item);
@@ -249,8 +254,9 @@ export default class ConversationSubgroup extends Ad4mModel {
         if (topicBase && !uniqueTopics.has(topicBase)) {
           uniqueTopics.set(topicBase, {
             topicBase,
-            topicName: parseLit(binding.topicNameRaw),
-            relevance: parseLit(binding.relevanceRaw),
+            // Typed XSD literals — no decode needed.
+            topicName: binding.topicNameRaw ?? '',
+            relevance: binding.relevanceRaw ?? '',
           });
         }
       }