@semiont/react-ui 0.5.1 → 0.5.3

package/src/features/resource-viewer/state/__tests__/resource-viewer-page-state-unit.test.ts

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { BehaviorSubject, Observable, firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { annotationId, resourceId as makeResourceId } from '@semiont/core';
+import type { ShellStateUnit } from '../../../../state/shell-state-unit';
+import { createResourceViewerPageStateUnit } from '../resource-viewer-page-state-unit';
+import { makeTestClient, type TestClient } from '../../../../__tests__/test-client';
+
+const RID = makeResourceId('res-1');
+
+function mockBrowse(): ShellStateUnit {
+  return {
+    activePanel$: new BehaviorSubject(null).asObservable(),
+    scrollToAnnotationId$: new BehaviorSubject(null).asObservable(),
+    panelInitialTab$: new BehaviorSubject(null).asObservable(),
+    onScrollCompleted: vi.fn(),
+    openPanel: vi.fn(),
+    closePanel: vi.fn(),
+    dispose: vi.fn(),
+  } as unknown as ShellStateUnit;
+}
+
+function clientWithNamespaces(overrides: {
+  annotations$?: BehaviorSubject<unknown[] | undefined>;
+  entityTypes$?: BehaviorSubject<string[] | undefined>;
+  events$?: BehaviorSubject<unknown[] | undefined>;
+  referencedBy$?: BehaviorSubject<unknown[] | undefined>;
+  resourceRepresentation?: ReturnType<typeof vi.fn>;
+  mediaToken?: ReturnType<typeof vi.fn>;
+} = {}): TestClient {
+  const annotations$ = overrides.annotations$ ?? new BehaviorSubject<unknown[] | undefined>([]);
+  const entityTypes$ = overrides.entityTypes$ ?? new BehaviorSubject<string[] | undefined>(['Person']);
+  const events$ = overrides.events$ ?? new BehaviorSubject<unknown[] | undefined>([]);
+  const referencedBy$ = overrides.referencedBy$ ?? new BehaviorSubject<unknown[] | undefined>([]);
+
+  return makeTestClient({
+    browse: {
+      annotations: () => annotations$.asObservable(),
+      entityTypes: () => entityTypes$.asObservable(),
+      events: () => events$.asObservable(),
+      referencedBy: () => referencedBy$.asObservable(),
+      resourceRepresentation: overrides.resourceRepresentation ?? vi.fn().mockResolvedValue({
+        data: new TextEncoder().encode('hello').buffer,
+        contentType: 'text/plain',
+      }),
+    },
+    auth: {
+      mediaToken: overrides.mediaToken ?? vi.fn().mockResolvedValue({ token: 'tok-123' }),
+    },
+    mark: {
+      annotation: vi.fn().mockResolvedValue({ annotationId: 'ann-new' }),
+      delete: vi.fn().mockResolvedValue(undefined),
+      assist: vi.fn(() => new Observable(() => {})),
+    },
+    gather: { annotation: vi.fn(() => new Observable(() => {})) },
+    match: { search: vi.fn(() => new Observable(() => {})) },
+    yield: { fromAnnotation: vi.fn(() => new Observable(() => {})) },
+    bind: { body: vi.fn().mockResolvedValue(undefined) },
+    subscribeToResource: vi.fn().mockReturnValue(() => {}),
+  });
+}
+
+describe('createResourceViewerPageStateUnit', () => {
+  let tc: TestClient;
+
+  afterEach(() => { tc?.bus.destroy(); });
+
+  it('exposes flow VMs', () => {
+    tc = clientWithNamespaces();
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    expect(stateUnit.beckon).toBeDefined();
+    expect(stateUnit.mark).toBeDefined();
+    expect(stateUnit.gather).toBeDefined();
+    expect(stateUnit.yield).toBeDefined();
+    expect(stateUnit.browse).toBeDefined();
+
+    stateUnit.dispose();
+  });
+
+  it('derives annotations from browse namespace', async () => {
+    const annotations$ = new BehaviorSubject<unknown[] | undefined>([
+      { id: 'a1', motivation: 'highlighting' },
+    ]);
+    tc = clientWithNamespaces({ annotations$ });
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    const anns = await firstValueFrom(stateUnit.annotations$);
+    expect(anns).toHaveLength(1);
+
+    stateUnit.dispose();
+  });
+
+  it('groups annotations by type', async () => {
+    const annotations$ = new BehaviorSubject<unknown[] | undefined>([
+      { id: 'a1', motivation: 'highlighting', target: { selector: { type: 'TextQuoteSelector', exact: 'x' } } },
+      { id: 'a2', motivation: 'commenting', body: [{ type: 'TextualBody', value: 'note' }], target: { selector: { type: 'TextQuoteSelector', exact: 'y' } } },
+    ]);
+    tc = clientWithNamespaces({ annotations$ });
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    const groups = await firstValueFrom(stateUnit.annotationGroups$);
+    expect(groups.highlights.length + groups.comments.length).toBeGreaterThanOrEqual(1);
+
+    stateUnit.dispose();
+  });
+
+  it('exposes entity types', async () => {
+    tc = clientWithNamespaces();
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    const types = await firstValueFrom(stateUnit.entityTypes$);
+    expect(types).toEqual(['Person']);
+
+    stateUnit.dispose();
+  });
+
+  it('exposes events from browse namespace', async () => {
+    const events$ = new BehaviorSubject<unknown[] | undefined>([{ id: 'e1', type: 'mark:added' }]);
+    tc = clientWithNamespaces({ events$ });
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    const events = await firstValueFrom(stateUnit.events$);
+    expect(events).toEqual([{ id: 'e1', type: 'mark:added' }]);
+
+    stateUnit.dispose();
+  });
+
+  it('exposes referencedBy from browse namespace', async () => {
+    const referencedBy$ = new BehaviorSubject<unknown[] | undefined>([{ resourceId: 'r2' }]);
+    tc = clientWithNamespaces({ referencedBy$ });
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    const refs = await firstValueFrom(stateUnit.referencedBy$);
+    expect(refs).toEqual([{ resourceId: 'r2' }]);
+
+    stateUnit.dispose();
+  });
+
+  it('fetches media token for binary types', async () => {
+    const mediaToken = vi.fn().mockResolvedValue({ token: 'tok-456' });
+    tc = clientWithNamespaces({ mediaToken });
+    const stateUnit = createResourceViewerPageStateUnit(
+      tc.client, RID, 'en', mockBrowse(),
+      { mediaType: 'image/png' },
+    );
+
+    const token = await firstValueFrom(stateUnit.mediaToken$.pipe(filter((t) => t !== null)));
+    expect(token).toBe('tok-456');
+
+    stateUnit.dispose();
+  });
+
+  it('wizard initializes closed', async () => {
+    tc = clientWithNamespaces();
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    const wizard = await firstValueFrom(stateUnit.wizard$);
+    expect(wizard.open).toBe(false);
+
+    stateUnit.dispose();
+  });
+
+  it('bind:initiate opens wizard and fires gather:requested', async () => {
+    tc = clientWithNamespaces();
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+    const gatherEvents: unknown[] = [];
+    tc.bus.get('gather:requested').subscribe((e) => gatherEvents.push(e));
+
+    tc.bus.get('bind:initiate').next({
+      annotationId: annotationId('ann-1'),
+      resourceId: makeResourceId('res-1'),
+      defaultTitle: 'Test',
+      entityTypes: ['Person'],
+    });
+
+    const wizard = await firstValueFrom(stateUnit.wizard$.pipe(filter((w) => w.open)));
+    expect(wizard.annotationId).toBe('ann-1');
+    expect(gatherEvents).toHaveLength(1);
+
+    stateUnit.dispose();
+  });
+
+  it('closeWizard resets wizard state', async () => {
+    tc = clientWithNamespaces();
+    const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());
+
+    tc.bus.get('bind:initiate').next({
+      annotationId: annotationId('ann-1'),
+      resourceId: makeResourceId('res-1'),
+      defaultTitle: 'Test',
+      entityTypes: [],
+    });
+
+    await firstValueFrom(stateUnit.wizard$.pipe(filter((w) => w.open)));
+    stateUnit.closeWizard();
+
+    const wizard = await firstValueFrom(stateUnit.wizard$.pipe(filter((w) => !w.open)));
+    expect(wizard.open).toBe(false);
+
+    stateUnit.dispose();
+  });
+});

package/src/features/resource-viewer/state/resource-loader-state-unit.ts

@@ -0,0 +1,26 @@
+import { type Observable, map } from 'rxjs';
+import type { ResourceDescriptor, ResourceId } from '@semiont/core';
+import type { StateUnit } from '@semiont/sdk';
+import type { SemiontClient } from '@semiont/sdk';
+
+export interface ResourceLoaderStateUnit extends StateUnit {
+  resource$: Observable<ResourceDescriptor | undefined>;
+  isLoading$: Observable<boolean>;
+  invalidate(): void;
+}
+
+export function createResourceLoaderStateUnit(
+  client: SemiontClient,
+  resourceId: ResourceId,
+): ResourceLoaderStateUnit {
+  const raw$ = client.browse.resource(resourceId);
+  const resource$ = raw$;
+  const isLoading$: Observable<boolean> = raw$.pipe(map((r) => r === undefined));
+
+  return {
+    resource$,
+    isLoading$,
+    invalidate: () => client.browse.invalidateResourceDetail(resourceId),
+    dispose: () => {},
+  };
+}

package/src/features/resource-viewer/state/resource-viewer-page-state-unit.ts

@@ -0,0 +1,180 @@
+import { BehaviorSubject, type Observable, map } from 'rxjs';
+import type { ResourceId, components } from '@semiont/core';
+import { createDisposer } from '@semiont/sdk';
+import type { StateUnit } from '@semiont/sdk';
+import type { ShellStateUnit } from '../../../state/shell-state-unit';
+import { createBeckonStateUnit, type BeckonStateUnit } from '@semiont/sdk';
+import { createMarkStateUnit, type MarkStateUnit } from '@semiont/sdk';
+import { createGatherStateUnit, type GatherStateUnit } from '@semiont/sdk';
+import { createMatchStateUnit } from '@semiont/sdk';
+import { createYieldStateUnit, type YieldStateUnit } from '@semiont/sdk';
+import type { SemiontClient } from '@semiont/sdk';
+import { decodeWithCharset } from '@semiont/core';
+import { isHighlight, isComment, isAssessment, isReference, isTag } from '@semiont/core';
+import type { ReferencedByEntry } from '@semiont/sdk';
+
+import type { Annotation } from '@semiont/core';
+
+export interface AnnotationGroups {
+  highlights: Annotation[];
+  comments: Annotation[];
+  assessments: Annotation[];
+  references: Annotation[];
+  tags: Annotation[];
+}
+type StoredEventResponse = components['schemas']['StoredEventResponse'];
+
+export interface WizardState {
+  open: boolean;
+  annotationId: string | null;
+  resourceId: string | null;
+  defaultTitle: string;
+  entityTypes: string[];
+}
+
+const WIZARD_CLOSED: WizardState = {
+  open: false, annotationId: null, resourceId: null, defaultTitle: '', entityTypes: [],
+};
+
+export interface ResourceViewerPageStateUnit extends StateUnit {
+  beckon: BeckonStateUnit;
+  browse: ShellStateUnit;
+  mark: MarkStateUnit;
+  gather: GatherStateUnit;
+  yield: YieldStateUnit;
+
+  annotations$: Observable<Annotation[]>;
+  annotationGroups$: Observable<AnnotationGroups>;
+  entityTypes$: Observable<string[]>;
+  events$: Observable<StoredEventResponse[]>;
+  referencedBy$: Observable<ReferencedByEntry[]>;
+  content$: Observable<string>;
+  contentLoading$: Observable<boolean>;
+  mediaToken$: Observable<string | null>;
+  wizard$: Observable<WizardState>;
+
+  closeWizard(): void;
+}
+
+export function createResourceViewerPageStateUnit(
+  client: SemiontClient,
+  resourceId: ResourceId,
+  locale: string,
+  browse: ShellStateUnit,
+  options?: { mediaType?: string },
+): ResourceViewerPageStateUnit {
+  const disposer = createDisposer();
+
+  const beckon = createBeckonStateUnit(client);
+  const mark = createMarkStateUnit(client, resourceId);
+  const gather = createGatherStateUnit(client, resourceId);
+  const matchStateUnit = createMatchStateUnit(client, resourceId);
+  const yieldStateUnit = createYieldStateUnit(client, resourceId, locale);
+
+  disposer.add(beckon);
+  disposer.add(browse);
+  disposer.add(mark);
+  disposer.add(gather);
+  disposer.add(matchStateUnit);
+  disposer.add(yieldStateUnit);
+
+  const annotations$: Observable<Annotation[]> = client.browse.annotations(resourceId).pipe(
+    map((a) => a ?? []),
+  );
+
+  const annotationGroups$: Observable<AnnotationGroups> = annotations$.pipe(
+    map((anns) => {
+      const groups: AnnotationGroups = { highlights: [], comments: [], assessments: [], references: [], tags: [] };
+      for (const ann of anns) {
+        if (isHighlight(ann)) groups.highlights.push(ann);
+        else if (isComment(ann)) groups.comments.push(ann);
+        else if (isAssessment(ann)) groups.assessments.push(ann);
+        else if (isReference(ann)) groups.references.push(ann);
+        else if (isTag(ann)) groups.tags.push(ann);
+      }
+      return groups;
+    }),
+  );
+
+  const entityTypes$: Observable<string[]> = client.browse.entityTypes().pipe(
+    map((e) => e ?? []),
+  );
+
+  const events$: Observable<StoredEventResponse[]> = client.browse.events(resourceId).pipe(
+    map((e) => e ?? []),
+  );
+
+  const referencedBy$: Observable<ReferencedByEntry[]> = client.browse.referencedBy(resourceId).pipe(
+    map((r) => r ?? []),
+  );
+
+  const content$ = new BehaviorSubject<string>('');
+  const contentLoading$ = new BehaviorSubject<boolean>(false);
+  const mediaToken$ = new BehaviorSubject<string | null>(null);
+
+  const mediaType = options?.mediaType || 'text/plain';
+  const isBinaryType = mediaType.startsWith('image/') || mediaType === 'application/pdf';
+
+  if (!isBinaryType && mediaType) {
+    contentLoading$.next(true);
+    client.browse.resourceRepresentation(resourceId, { accept: mediaType })
+      .then(({ data }) => {
+        content$.next(decodeWithCharset(data, mediaType));
+        contentLoading$.next(false);
+      })
+      .catch(() => { contentLoading$.next(false); });
+  }
+
+  if (isBinaryType) {
+    client.auth!.mediaToken(resourceId)
+      .then(({ token }) => mediaToken$.next(token))
+      .catch(() => {});
+  }
+
+  const wizard$ = new BehaviorSubject<WizardState>(WIZARD_CLOSED);
+
+  const unsubscribeResource = client.subscribeToResource(resourceId);
+  disposer.add(unsubscribeResource);
+
+  const bindInitiateSub = client.bus.get('bind:initiate').subscribe((event) => {
+    wizard$.next({
+      open: true,
+      annotationId: event.annotationId,
+      resourceId: event.resourceId,
+      defaultTitle: event.defaultTitle,
+      entityTypes: event.entityTypes,
+    });
+    client.bus.get('gather:requested').next({
+      correlationId: crypto.randomUUID(),
+      annotationId: event.annotationId,
+      resourceId: event.resourceId,
+      options: { contextWindow: 2000 },
+    });
+  });
+  disposer.add(() => bindInitiateSub.unsubscribe());
+
+  return {
+    beckon,
+    browse,
+    mark,
+    gather,
+    yield: yieldStateUnit,
+    annotations$,
+    annotationGroups$,
+    entityTypes$,
+    events$,
+    referencedBy$,
+    content$: content$.asObservable(),
+    contentLoading$: contentLoading$.asObservable(),
+    mediaToken$: mediaToken$.asObservable(),
+    wizard$: wizard$.asObservable(),
+    closeWizard: () => wizard$.next(WIZARD_CLOSED),
+    dispose: () => {
+      wizard$.complete();
+      content$.complete();
+      contentLoading$.complete();
+      mediaToken$.complete();
+      disposer.dispose();
+    },
+  };
+}

package/translations/ar.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "العلامات",
     "noTags": "لا توجد علامات بعد. استخدم التوضيح بالذكاء الاصطناعي لتحديد الأدوار الهيكلية.",
+    "noSchemas": "لا توجد مخططات وسوم مسجلة لقاعدة المعارف هذه. يجب على مسؤول قاعدة المعارف تسجيل مخطط تحليل هيكلي واحد على الأقل (مثلاً عبر مهارة `register-tag-schemas`) قبل استخدام الوسم.",
     "annotateTags": "توضيح العلامات",
     "selectSchema": "اختيار الإطار",
-    "schemaLegal": "التحليل القانوني (IRAC)",
-    "schemaScientific": "الورقة العلمية (IMRAD)",
-    "schemaArgument": "بنية الحجة (Toulmin)",
     "selectCategories": "اختيار الفئات",
-    "categoryIssue": "القضية",
-    "categoryRule": "القاعدة",
-    "categoryApplication": "التطبيق",
-    "categoryConclusion": "الخاتمة",
-    "categoryIntroduction": "المقدمة",
-    "categoryMethods": "المناهج",
-    "categoryResults": "النتائج",
-    "categoryDiscussion": "المناقشة",
-    "categoryClaim": "الادعاء",
-    "categoryEvidence": "الدليل",
-    "categoryWarrant": "المبرر",
-    "categoryCounterargument": "الحجة المضادة",
-    "categoryRebuttal": "الدحض",
     "annotate": "توضيح",
     "annotating": "جارٍ التوضيح...",
     "cancel": "إلغاء",

package/translations/bn.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "ট্যাগসমূহ",
     "noTags": "এখনো কোনো ট্যাগ নেই। কাঠামোগত ভূমিকা শনাক্ত করতে AI টীকাকরণ ব্যবহার করুন।",
+    "noSchemas": "এই জ্ঞান ভাণ্ডারের জন্য কোনো ট্যাগ স্কিমা নিবন্ধিত নেই। ট্যাগিং ব্যবহার করার আগে একজন KB প্রশাসককে কমপক্ষে একটি কাঠামোগত-বিশ্লেষণ স্কিমা নিবন্ধন করতে হবে (যেমন `register-tag-schemas` দক্ষতার মাধ্যমে)।",
     "annotateTags": "ট্যাগ টীকাকরণ",
     "selectSchema": "ফ্রেমওয়ার্ক নির্বাচন করুন",
-    "schemaLegal": "আইনি বিশ্লেষণ (IRAC)",
-    "schemaScientific": "বৈজ্ঞানিক গবেষণাপত্র (IMRAD)",
-    "schemaArgument": "যুক্তি কাঠামো (Toulmin)",
     "selectCategories": "বিভাগ নির্বাচন করুন",
-    "categoryIssue": "বিষয়",
-    "categoryRule": "নিয়ম",
-    "categoryApplication": "প্রয়োগ",
-    "categoryConclusion": "উপসংহার",
-    "categoryIntroduction": "ভূমিকা",
-    "categoryMethods": "পদ্ধতি",
-    "categoryResults": "ফলাফল",
-    "categoryDiscussion": "আলোচনা",
-    "categoryClaim": "দাবি",
-    "categoryEvidence": "প্রমাণ",
-    "categoryWarrant": "যুক্তিসূত্র",
-    "categoryCounterargument": "প্রতিযুক্তি",
-    "categoryRebuttal": "খণ্ডন",
     "annotate": "টীকাকরণ",
     "annotating": "টীকাকরণ হচ্ছে...",
     "cancel": "বাতিল করুন",

package/translations/cs.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "Štítky",
     "noTags": "Zatím žádné štítky. Použijte AI anotaci pro identifikaci strukturálních rolí.",
+    "noSchemas": "Pro tuto znalostní bázi nejsou registrována žádná schémata značek. Správce KB musí zaregistrovat alespoň jedno schéma strukturální analýzy (např. pomocí dovednosti `register-tag-schemas`), než bude možné používat značkování.",
     "annotateTags": "Anotovat štítky",
     "selectSchema": "Vybrat rámec",
-    "schemaLegal": "Právní analýza (IRAC)",
-    "schemaScientific": "Vědecký článek (IMRAD)",
-    "schemaArgument": "Struktura argumentace (Toulmin)",
     "selectCategories": "Vybrat kategorie",
-    "categoryIssue": "Otázka",
-    "categoryRule": "Pravidlo",
-    "categoryApplication": "Aplikace",
-    "categoryConclusion": "Závěr",
-    "categoryIntroduction": "Úvod",
-    "categoryMethods": "Metody",
-    "categoryResults": "Výsledky",
-    "categoryDiscussion": "Diskuze",
-    "categoryClaim": "Tvrzení",
-    "categoryEvidence": "Důkaz",
-    "categoryWarrant": "Odůvodnění",
-    "categoryCounterargument": "Protiargument",
-    "categoryRebuttal": "Vyvrácení",
     "annotate": "Anotovat",
     "annotating": "Anotování...",
     "cancel": "Zrušit",

package/translations/da.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "Tags",
     "noTags": "Ingen tags endnu. Brug AI-annotering til at identificere strukturelle roller.",
+    "noSchemas": "Ingen tag-skemaer registreret for denne videnbase. En KB-administrator skal registrere mindst ét struktur-analyse-skema (f.eks. via `register-tag-schemas`-færdigheden), før tagging kan bruges.",
     "annotateTags": "Annoter tags",
     "selectSchema": "Vælg rammestruktur",
-    "schemaLegal": "Juridisk analyse (IRAC)",
-    "schemaScientific": "Videnskabelig artikel (IMRAD)",
-    "schemaArgument": "Argumentstruktur (Toulmin)",
     "selectCategories": "Vælg kategorier",
-    "categoryIssue": "Problem",
-    "categoryRule": "Regel",
-    "categoryApplication": "Anvendelse",
-    "categoryConclusion": "Konklusion",
-    "categoryIntroduction": "Introduktion",
-    "categoryMethods": "Metoder",
-    "categoryResults": "Resultater",
-    "categoryDiscussion": "Diskussion",
-    "categoryClaim": "Påstand",
-    "categoryEvidence": "Dokumentation",
-    "categoryWarrant": "Begrundelse",
-    "categoryCounterargument": "Modargument",
-    "categoryRebuttal": "Gendrivelse",
     "annotate": "Annoter",
     "annotating": "Annoterer...",
     "cancel": "Annuller",

package/translations/de.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "Tags",
     "noTags": "Noch keine Tags. Verwenden Sie die KI-Annotation, um strukturelle Rollen zu identifizieren.",
+    "noSchemas": "Für diese Wissensbasis sind keine Tag-Schemata registriert. Ein KB-Administrator muss mindestens ein Strukturanalyse-Schema registrieren (z. B. über den `register-tag-schemas`-Skill), bevor Tagging verwendet werden kann.",
     "annotateTags": "Tags annotieren",
     "selectSchema": "Framework auswählen",
-    "schemaLegal": "Juristische Analyse (IRAC)",
-    "schemaScientific": "Wissenschaftliche Arbeit (IMRAD)",
-    "schemaArgument": "Argumentationsstruktur (Toulmin)",
     "selectCategories": "Kategorien auswählen",
-    "categoryIssue": "Fragestellung",
-    "categoryRule": "Regel",
-    "categoryApplication": "Anwendung",
-    "categoryConclusion": "Schlussfolgerung",
-    "categoryIntroduction": "Einleitung",
-    "categoryMethods": "Methoden",
-    "categoryResults": "Ergebnisse",
-    "categoryDiscussion": "Diskussion",
-    "categoryClaim": "These",
-    "categoryEvidence": "Beweis",
-    "categoryWarrant": "Begründung",
-    "categoryCounterargument": "Gegenargument",
-    "categoryRebuttal": "Widerlegung",
     "annotate": "Annotieren",
     "annotating": "Wird annotiert...",
     "cancel": "Abbrechen",

package/translations/el.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "Ετικέτες",
     "noTags": "Δεν υπάρχουν ετικέτες ακόμα. Χρησιμοποιήστε τον σχολιασμό AI για να αναγνωρίσετε δομικούς ρόλους.",
+    "noSchemas": "Δεν υπάρχουν εγγεγραμμένα σχήματα ετικετών για αυτή τη βάση γνώσης. Ένας διαχειριστής KB πρέπει να εγγράψει τουλάχιστον ένα σχήμα δομικής ανάλυσης (π.χ. μέσω της δεξιότητας `register-tag-schemas`) πριν χρησιμοποιηθεί η ετικετοποίηση.",
     "annotateTags": "Σχολιασμός Ετικετών",
     "selectSchema": "Επιλογή Πλαισίου",
-    "schemaLegal": "Νομική Ανάλυση (IRAC)",
-    "schemaScientific": "Επιστημονικό Άρθρο (IMRAD)",
-    "schemaArgument": "Δομή Επιχειρήματος (Toulmin)",
     "selectCategories": "Επιλογή Κατηγοριών",
-    "categoryIssue": "Ζήτημα",
-    "categoryRule": "Κανόνας",
-    "categoryApplication": "Εφαρμογή",
-    "categoryConclusion": "Συμπέρασμα",
-    "categoryIntroduction": "Εισαγωγή",
-    "categoryMethods": "Μέθοδοι",
-    "categoryResults": "Αποτελέσματα",
-    "categoryDiscussion": "Συζήτηση",
-    "categoryClaim": "Ισχυρισμός",
-    "categoryEvidence": "Τεκμήριο",
-    "categoryWarrant": "Αιτιολόγηση",
-    "categoryCounterargument": "Αντεπιχείρημα",
-    "categoryRebuttal": "Ανασκευή",
     "annotate": "Σχολιασμός",
     "annotating": "Σχολιασμός...",
     "cancel": "Ακύρωση",

package/translations/en.json

@@ -149,25 +149,10 @@
   "TaggingPanel": {
     "title": "Tags",
     "noTags": "No tags yet. Use AI annotation to identify structural roles.",
+    "noSchemas": "No tag schemas registered for this knowledge base. A KB administrator must register at least one structural-analysis schema (e.g. via the `register-tag-schemas` skill) before tagging can be used.",
     "annotateTags": "Annotate Tags",
     "selectSchema": "Select Framework",
-    "schemaLegal": "Legal Analysis (IRAC)",
-    "schemaScientific": "Scientific Paper (IMRAD)",
-    "schemaArgument": "Argument Structure (Toulmin)",
     "selectCategories": "Select Categories",
-    "categoryIssue": "Issue",
-    "categoryRule": "Rule",
-    "categoryApplication": "Application",
-    "categoryConclusion": "Conclusion",
-    "categoryIntroduction": "Introduction",
-    "categoryMethods": "Methods",
-    "categoryResults": "Results",
-    "categoryDiscussion": "Discussion",
-    "categoryClaim": "Claim",
-    "categoryEvidence": "Evidence",
-    "categoryWarrant": "Warrant",
-    "categoryCounterargument": "Counterargument",
-    "categoryRebuttal": "Rebuttal",
     "annotate": "Annotate",
     "annotating": "Annotating...",
     "cancel": "Cancel",

package/translations/es.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "Etiquetas",
     "noTags": "Aún no hay etiquetas. Usa anotación por IA para identificar roles estructurales.",
+    "noSchemas": "No hay esquemas de etiquetas registrados para esta base de conocimiento. Un administrador de la KB debe registrar al menos un esquema de análisis estructural (p. ej. mediante la habilidad `register-tag-schemas`) antes de poder usar el etiquetado.",
     "annotateTags": "Anotar Etiquetas",
     "selectSchema": "Seleccionar Marco",
-    "schemaLegal": "Análisis Legal (IRAC)",
-    "schemaScientific": "Artículo Científico (IMRAD)",
-    "schemaArgument": "Estructura de Argumento (Toulmin)",
     "selectCategories": "Seleccionar Categorías",
-    "categoryIssue": "Cuestión",
-    "categoryRule": "Regla",
-    "categoryApplication": "Aplicación",
-    "categoryConclusion": "Conclusión",
-    "categoryIntroduction": "Introducción",
-    "categoryMethods": "Métodos",
-    "categoryResults": "Resultados",
-    "categoryDiscussion": "Discusión",
-    "categoryClaim": "Afirmación",
-    "categoryEvidence": "Evidencia",
-    "categoryWarrant": "Garantía",
-    "categoryCounterargument": "Contraargumento",
-    "categoryRebuttal": "Refutación",
     "assist": "Asistir",
     "assisting": "Asistiendo...",
     "cancel": "Cancelar",

package/translations/fa.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "برچسب‌ها",
     "noTags": "هنوز برچسبی وجود ندارد. از حاشیه‌نویسی هوش مصنوعی برای شناسایی نقش‌های ساختاری استفاده کنید.",
+    "noSchemas": "هیچ طرحواره برچسبی برای این پایگاه دانش ثبت نشده است. مدیر پایگاه دانش باید پیش از استفاده از برچسب‌گذاری حداقل یک طرحواره تحلیل ساختاری ثبت کند (مثلاً از طریق مهارت `register-tag-schemas`).",
     "annotateTags": "حاشیه‌نویسی برچسب‌ها",
     "selectSchema": "انتخاب چارچوب",
-    "schemaLegal": "تحلیل حقوقی (IRAC)",
-    "schemaScientific": "مقاله علمی (IMRAD)",
-    "schemaArgument": "ساختار استدلال (Toulmin)",
     "selectCategories": "انتخاب دسته‌بندی‌ها",
-    "categoryIssue": "مسئله",
-    "categoryRule": "قاعده",
-    "categoryApplication": "کاربرد",
-    "categoryConclusion": "نتیجه‌گیری",
-    "categoryIntroduction": "مقدمه",
-    "categoryMethods": "روش‌ها",
-    "categoryResults": "نتایج",
-    "categoryDiscussion": "بحث",
-    "categoryClaim": "ادعا",
-    "categoryEvidence": "شواهد",
-    "categoryWarrant": "توجیه",
-    "categoryCounterargument": "استدلال مخالف",
-    "categoryRebuttal": "پاسخ به استدلال مخالف",
     "annotate": "حاشیه‌نویسی",
     "annotating": "در حال حاشیه‌نویسی...",
     "cancel": "انصراف",