@semiont/ontology 0.5.2 → 0.5.4

package/README.md

@@ -6,14 +6,15 @@
 [![npm downloads](https://img.shields.io/npm/dm/@semiont/ontology.svg)](https://www.npmjs.com/package/@semiont/ontology)
 [![License](https://img.shields.io/npm/l/@semiont/ontology.svg)](https://github.com/The-AI-Alliance/semiont/blob/main/LICENSE)
 
-Entity types, tag schemas, and tag extraction utilities for the Semiont annotation system.
+Entity types and annotation-body extraction utilities for the Semiont annotation system.
 
 ## Overview
 
-This package consolidates ontology-related code that was previously scattered across the codebase:
-- **Entity types**: Semantic categories for tagging resources and annotations (Person, Organization, Location, etc.)
-- **Tag schemas**: Structural analysis frameworks (IRAC for legal, IMRAD for scientific, Toulmin for argumentation)
-- **Tag extraction**: Utilities for extracting tag information from W3C annotations
+This package owns:
+- **Entity types**: Semantic categories for tagging resources and annotations (Person, Organization, Location, etc.) — `DEFAULT_ENTITY_TYPES` plus the extraction helper `getEntityTypes`.
+- **Tag extraction helpers**: Pure body-readers (`getTagCategory`, `getTagSchemaId`) that pull schema provenance off an annotation's body. They don't depend on the schema registry.
+
+**Tag schemas are not stored in this package.** Schemas are runtime-registered per knowledge base via `frame.addTagSchema(...)` from the SDK; the `TagSchema` and `TagCategory` *types* are exported from `@semiont/core`. The schema *data* lives with the KB that owns it (typically a `src/tag-schemas.ts` module in the KB repo).
 
 ## Installation
 
@@ -37,34 +38,20 @@ console.log(DEFAULT_ENTITY_TYPES);
 
 ### Tag Schemas
 
-Three built-in tag schemas for structural document analysis:
+Tag schemas are runtime-registered per KB (see [`docs/protocol/skills/semiont-tag/SKILL.md`](../../docs/protocol/skills/semiont-tag/SKILL.md) and [`.plans/TAG-SCHEMAS-GAP.md`](../../.plans/TAG-SCHEMAS-GAP.md)). The `TagSchema` and `TagCategory` *types* live in `@semiont/core`; schema *data* lives with the KB that owns it. Use `frame.addTagSchema(schema)` to register and `browse.tagSchemas()` to enumerate registered schemas.
 
 ```typescript
-import {
-  TAG_SCHEMAS,
-  getTagSchema,
-  getAllTagSchemas,
-  getTagSchemasByDomain
-} from '@semiont/ontology';
-
-// Get a specific schema
-const iracSchema = getTagSchema('legal-irac');
-// Returns: { id: 'legal-irac', name: 'Legal Analysis (IRAC)',
-//           domain: 'legal', tags: [...] }
-
-// Get all schemas
-const allSchemas = getAllTagSchemas();
-// Returns array of all 3 schemas
-
-// Get schemas by domain
-const legalSchemas = getTagSchemasByDomain('legal');
-// Returns schemas where domain === 'legal'
-```
+import { SemiontClient, type TagSchema } from '@semiont/sdk';
 
-Available schemas (from [src/tag-schemas.ts](src/tag-schemas.ts)):
-- `legal-irac`: Legal Analysis (IRAC) - Issue, Rule, Application, Conclusion
-- `scientific-imrad`: Scientific Paper (IMRAD) - Introduction, Methods, Results, Discussion
-- `argument-toulmin`: Argument Structure (Toulmin) - Claim, Evidence, Warrant, Counterargument, Rebuttal
+const semiont = await SemiontClient.signInHttp({ /* ... */ });
+
+// Register a schema (idempotent — same content re-registered is silent)
+const SCHEMA: TagSchema = { id: 'my-schema', name: '...', /* ... */ };
+await semiont.frame.addTagSchema(SCHEMA);
+
+// Enumerate registered schemas
+const all = await semiont.browse.tagSchemas();
+```
 
 ### Entity Extraction
 
@@ -117,30 +104,6 @@ const schemaId = getTagSchemaId(tagAnnotation);
 
 From [src/tag-extraction.ts](src/tag-extraction.ts): Tag annotations use dual-body structure with `purpose: 'tagging'` for category and `purpose: 'classifying'` for schema ID.
 
-### Tag Schema Helpers
-
-```typescript
-import { isValidCategory, getSchemaCategory } from '@semiont/ontology';
-
-// Check if a category exists in a schema
-const isValid = isValidCategory('legal-irac', 'Issue');
-// Returns: true
-
-const invalid = isValidCategory('legal-irac', 'Conclusion');
-// Returns: true (all 4 IRAC categories are valid)
-
-const notValid = isValidCategory('legal-irac', 'Introduction');
-// Returns: false (Introduction is IMRAD, not IRAC)
-
-// Get category details
-const category = getSchemaCategory('legal-irac', 'Rule');
-// Returns: {
-//   name: 'Rule',
-//   description: 'The relevant law, statute, or legal principle',
-//   examples: ['What law applies?', 'What is the legal standard?', ...]
-// }
-```
-
 ## Tag Collections
 
 Type definitions for graph database tag collection operations:
@@ -181,10 +144,8 @@ packages/ontology/
 │   ├── index.ts                # Public API exports
 │   ├── entity-types.ts         # DEFAULT_ENTITY_TYPES
 │   ├── tag-collections.ts      # TagCollection interfaces
-│   ├── tag-schemas.ts          # TAG_SCHEMAS registry
 │   ├── entity-extraction.ts    # getEntityTypes utility
-│   ├── tag-extraction.ts       # getTagCategory, getTagSchemaId
-│   └── bootstrap.ts            # Re-export note (actual bootstrap in backend)
+│   └── tag-extraction.ts       # getTagCategory, getTagSchemaId
 ├── package.json
 ├── tsconfig.json
 ├── tsup.config.ts

package/dist/bootstrap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Entity Types Bootstrap - moved to backend
+ *
+ * NOTE: The bootstrap service has been moved back to apps/backend/src/bootstrap/entity-types-bootstrap.ts
+ * to avoid circular dependency between @semiont/ontology and @semiont/core.
+ *
+ * Only DEFAULT_ENTITY_TYPES is exported from this package.
+ * The bootstrap logic depends on EnvironmentConfig from @semiont/core and EventStore from backend,
+ * so it belongs in the backend, not in the ontology package.
+ */
+export { DEFAULT_ENTITY_TYPES } from './entity-types';
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/entity-extraction.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Entity Type Extraction Utilities
+ *
+ * Extract entity types from annotation bodies.
+ * Entity types are stored as TextualBody with purpose: "tagging"
+ */
+import type { Annotation } from '@semiont/core';
+/**
+ * Extract entity types from annotation bodies
+ * Entity types are stored as TextualBody with purpose: "tagging"
+ * Accepts any object with a body property matching Annotation['body'].
+ * Body is optional (highlights carry none) — returns [] if absent.
+ */
+export declare function getEntityTypes(annotation: {
+    body?: Annotation['body'];
+}): string[];
+//# sourceMappingURL=entity-extraction.d.ts.map

package/dist/entity-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-extraction.d.ts","sourceRoot":"","sources":["../src/entity-extraction.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE;IAAE,IAAI,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;CAAE,GAAG,MAAM,EAAE,CA8BlF"}

package/dist/entity-types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Default entity types for the Semiont system
+ *
+ * Entity types are used to tag resources and annotations with semantic categories.
+ * These types serve as initial seed data for the entity types collection.
+ */
+export declare const DEFAULT_ENTITY_TYPES: string[];
+//# sourceMappingURL=entity-types.d.ts.map

package/dist/entity-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-types.d.ts","sourceRoot":"","sources":["../src/entity-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,UAUhC,CAAC"}

package/dist/index.d.ts

@@ -1,131 +1,16 @@
-import { Annotation } from '@semiont/core';
-
 /**
- * Default entity types for the Semiont system
+ * @semiont/ontology
  *
- * Entity types are used to tag resources and annotations with semantic categories.
- * These types serve as initial seed data for the entity types collection.
- */
-declare const DEFAULT_ENTITY_TYPES: string[];
-
-/**
- * Tag Collections Management
- *
- * Stores entity types in the graph database as append-only collections.
- * Provides interface for graph database implementations to manage entity type collections.
- */
-interface TagCollection {
-    id: string;
-    collectionType: 'entity-types';
-    tags: string[];
-    created: Date;
-    updatedAt: Date;
-}
-interface TagCollectionOperations {
-    /**
-     * Get or create collections with auto-seeding
-     */
-    getEntityTypes(): Promise<string[]>;
-    /**
-     * Append new tag (no duplicates)
-     */
-    addEntityType(tag: string): Promise<void>;
-    /**
-     * Bulk append tags
-     */
-    addEntityTypes(tags: string[]): Promise<void>;
-    /**
-     * Check if collections exist
-     */
-    hasEntityTypesCollection(): Promise<boolean>;
-    /**
-     * Initialize collections with seed data if they don't exist
-     */
-    initializeCollections(): Promise<void>;
-}
-
-/**
- * Tag Schema Registry
- *
- * Defines structural analysis frameworks for automatic tagging detection.
- * Each schema provides categories that passages can be classified into
- * based on their structural role (not their semantic content).
+ * Entity-type vocabulary + annotation-body extraction utilities.
  *
- * Examples: IRAC (legal), IMRAD (scientific), Toulmin (argumentation)
- */
-interface TagCategory {
-    name: string;
-    description: string;
-    examples: string[];
-}
-interface TagSchema {
-    id: string;
-    name: string;
-    description: string;
-    domain: 'legal' | 'scientific' | 'general';
-    tags: TagCategory[];
-}
-declare const TAG_SCHEMAS: Record<string, TagSchema>;
-/**
- * Get a tag schema by ID
- */
-declare function getTagSchema(schemaId: string): TagSchema | null;
-/**
- * Get all available tag schemas
- */
-declare function getAllTagSchemas(): TagSchema[];
-/**
- * Get tag schemas filtered by domain
- */
-declare function getTagSchemasByDomain(domain: 'legal' | 'scientific' | 'general'): TagSchema[];
-/**
- * Validate that a category name is valid for a schema
- */
-declare function isValidCategory(schemaId: string, categoryName: string): boolean;
-/**
- * Get a specific category from a schema
- */
-declare function getSchemaCategory(schemaId: string, categoryName: string): TagCategory | null;
-
-/**
- * Entity Type Extraction Utilities
- *
- * Extract entity types from annotation bodies.
- * Entity types are stored as TextualBody with purpose: "tagging"
- */
-
-/**
- * Extract entity types from annotation bodies
- * Entity types are stored as TextualBody with purpose: "tagging"
- * Accepts any object with a body property matching Annotation['body'].
- * Body is optional (highlights carry none) — returns [] if absent.
- */
-declare function getEntityTypes(annotation: {
-    body?: Annotation['body'];
-}): string[];
-
-/**
- * Tag Schema Extraction Utilities
- *
- * Extract tag categories and schema IDs from tag annotations.
- * Tags use dual-body structure:
- * - First body has purpose: "tagging" with category value
- * - Second body has purpose: "classifying" with schema ID
- */
-
-/**
- * Extract tag category from a tag annotation's body
- * Tags use dual-body structure: first body has purpose: "tagging" with category value
- * @param annotation - The annotation to extract category from
- * @returns The tag category (e.g., "Issue", "Rule"), or undefined if not a tag or no category found
- */
-declare function getTagCategory(annotation: Annotation): string | undefined;
-/**
- * Extract tag schema ID from a tag annotation's body
- * Tags use dual-body structure: second body has purpose: "classifying" with schema ID
- * @param annotation - The annotation to extract schema ID from
- * @returns The schema ID (e.g., "legal-irac"), or undefined if not a tag or no schema found
- */
-declare function getTagSchemaId(annotation: Annotation): string | undefined;
-
-export { DEFAULT_ENTITY_TYPES, TAG_SCHEMAS, type TagCategory, type TagCollection, type TagCollectionOperations, type TagSchema, getAllTagSchemas, getEntityTypes, getSchemaCategory, getTagCategory, getTagSchema, getTagSchemaId, getTagSchemasByDomain, isValidCategory };
+ * Note: tag-schema *data* lives with the KB that owns it (registered at
+ * runtime via `frame.addTagSchema(...)`). The `TagSchema` and `TagCategory`
+ * *types* are exported from `@semiont/core`. This package owns only the
+ * extraction helpers (`getTagCategory`, `getTagSchemaId`) that read schema
+ * provenance off an annotation's body.
+ */
+export { DEFAULT_ENTITY_TYPES } from './entity-types';
+export type { TagCollection, TagCollectionOperations } from './tag-collections';
+export { getEntityTypes } from './entity-extraction';
+export { getTagCategory, getTagSchemaId } from './tag-extraction';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGtD,YAAY,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAGhF,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -11,170 +11,6 @@ var DEFAULT_ENTITY_TYPES = [
   "Author"
 ];
 
-// src/tag-schemas.ts
-var TAG_SCHEMAS = {
-  "legal-irac": {
-    id: "legal-irac",
-    name: "Legal Analysis (IRAC)",
-    description: "Issue, Rule, Application, Conclusion framework for legal reasoning",
-    domain: "legal",
-    tags: [
-      {
-        name: "Issue",
-        description: "The legal question or problem to be resolved",
-        examples: [
-          "What is the central legal question?",
-          "What must the court decide?",
-          "What is the dispute about?"
-        ]
-      },
-      {
-        name: "Rule",
-        description: "The relevant law, statute, or legal principle",
-        examples: [
-          "What law applies?",
-          "What is the legal standard?",
-          "What statute governs this case?"
-        ]
-      },
-      {
-        name: "Application",
-        description: "How the rule applies to the specific facts",
-        examples: [
-          "How does the law apply to these facts?",
-          "Analysis of the case",
-          "How do the facts satisfy the legal standard?"
-        ]
-      },
-      {
-        name: "Conclusion",
-        description: "The resolution or outcome based on the analysis",
-        examples: [
-          "What is the court's decision?",
-          "What is the final judgment?",
-          "What is the holding?"
-        ]
-      }
-    ]
-  },
-  "scientific-imrad": {
-    id: "scientific-imrad",
-    name: "Scientific Paper (IMRAD)",
-    description: "Introduction, Methods, Results, Discussion structure for research papers",
-    domain: "scientific",
-    tags: [
-      {
-        name: "Introduction",
-        description: "Background, context, and research question",
-        examples: [
-          "What is the research question?",
-          "Why is this important?",
-          "What is the hypothesis?"
-        ]
-      },
-      {
-        name: "Methods",
-        description: "Experimental design and procedures",
-        examples: [
-          "How was the study conducted?",
-          "What methods were used?",
-          "What was the experimental design?"
-        ]
-      },
-      {
-        name: "Results",
-        description: "Findings and observations",
-        examples: [
-          "What did the study find?",
-          "What are the data?",
-          "What were the observations?"
-        ]
-      },
-      {
-        name: "Discussion",
-        description: "Interpretation and implications of results",
-        examples: [
-          "What do the results mean?",
-          "What are the implications?",
-          "How do these findings relate to prior work?"
-        ]
-      }
-    ]
-  },
-  "argument-toulmin": {
-    id: "argument-toulmin",
-    name: "Argument Structure (Toulmin)",
-    description: "Claim, Evidence, Warrant, Counterargument, Rebuttal framework for argumentation",
-    domain: "general",
-    tags: [
-      {
-        name: "Claim",
-        description: "The main assertion or thesis",
-        examples: [
-          "What is being argued?",
-          "What is the main point?",
-          "What position is being taken?"
-        ]
-      },
-      {
-        name: "Evidence",
-        description: "Data or facts supporting the claim",
-        examples: [
-          "What supports this claim?",
-          "What are the facts?",
-          "What data is provided?"
-        ]
-      },
-      {
-        name: "Warrant",
-        description: "Reasoning connecting evidence to claim",
-        examples: [
-          "Why does this evidence support the claim?",
-          "What is the logic?",
-          "How does this reasoning work?"
-        ]
-      },
-      {
-        name: "Counterargument",
-        description: "Opposing viewpoints or objections",
-        examples: [
-          "What are the objections?",
-          "What do critics say?",
-          "What are alternative views?"
-        ]
-      },
-      {
-        name: "Rebuttal",
-        description: "Response to counterarguments",
-        examples: [
-          "How is the objection addressed?",
-          "Why is the counterargument wrong?",
-          "How is the criticism answered?"
-        ]
-      }
-    ]
-  }
-};
-function getTagSchema(schemaId) {
-  return TAG_SCHEMAS[schemaId] || null;
-}
-function getAllTagSchemas() {
-  return Object.values(TAG_SCHEMAS);
-}
-function getTagSchemasByDomain(domain) {
-  return Object.values(TAG_SCHEMAS).filter((schema) => schema.domain === domain);
-}
-function isValidCategory(schemaId, categoryName) {
-  const schema = getTagSchema(schemaId);
-  if (!schema) return false;
-  return schema.tags.some((tag) => tag.name === categoryName);
-}
-function getSchemaCategory(schemaId, categoryName) {
-  const schema = getTagSchema(schemaId);
-  if (!schema) return null;
-  return schema.tags.find((tag) => tag.name === categoryName) || null;
-}
-
 // src/entity-extraction.ts
 function getEntityTypes(annotation) {
   if (Array.isArray(annotation.body)) {
@@ -222,14 +58,8 @@ function getTagSchemaId(annotation) {
 }
 export {
   DEFAULT_ENTITY_TYPES,
-  TAG_SCHEMAS,
-  getAllTagSchemas,
   getEntityTypes,
-  getSchemaCategory,
   getTagCategory,
-  getTagSchema,
-  getTagSchemaId,
-  getTagSchemasByDomain,
-  isValidCategory
+  getTagSchemaId
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/entity-types.ts","../src/tag-schemas.ts","../src/entity-extraction.ts","../src/tag-extraction.ts"],"sourcesContent":["/**\n * Default entity types for the Semiont system\n *\n * Entity types are used to tag resources and annotations with semantic categories.\n * These types serve as initial seed data for the entity types collection.\n */\nexport const DEFAULT_ENTITY_TYPES = [\n  'Person',\n  'Organization',\n  'Location',\n  'Event',\n  'Concept',\n  'Product',\n  'Technology',\n  'Date',\n  'Author'\n];\n","/**\n * Tag Schema Registry\n *\n * Defines structural analysis frameworks for automatic tagging detection.\n * Each schema provides categories that passages can be classified into\n * based on their structural role (not their semantic content).\n *\n * Examples: IRAC (legal), IMRAD (scientific), Toulmin (argumentation)\n */\n\nexport interface TagCategory {\n  name: string;\n  description: string;\n  examples: string[];\n}\n\nexport interface TagSchema {\n  id: string;\n  name: string;\n  description: string;\n  domain: 'legal' | 'scientific' | 'general';\n  tags: TagCategory[];\n}\n\nexport const TAG_SCHEMAS: Record<string, TagSchema> = {\n  'legal-irac': {\n    id: 'legal-irac',\n    name: 'Legal Analysis (IRAC)',\n    description: 'Issue, Rule, Application, Conclusion framework for legal reasoning',\n    domain: 'legal',\n    tags: [\n      {\n        name: 'Issue',\n        description: 'The legal question or problem to be resolved',\n        examples: [\n          'What is the central legal question?',\n          'What must the court decide?',\n          'What is the dispute about?'\n        ]\n      },\n      {\n        name: 'Rule',\n        description: 'The relevant law, statute, or legal principle',\n        examples: [\n          'What law applies?',\n          'What is the legal standard?',\n          'What statute governs this case?'\n        ]\n      },\n      {\n        name: 'Application',\n        description: 'How the rule applies to the specific facts',\n        examples: [\n          'How does the law apply to these facts?',\n          'Analysis of the case',\n          'How do the facts satisfy the legal standard?'\n        ]\n      },\n      {\n        name: 'Conclusion',\n        description: 'The resolution or outcome based on the analysis',\n        examples: [\n          'What is the court\\'s decision?',\n          'What is the final judgment?',\n          'What is the holding?'\n        ]\n      }\n    ]\n  },\n\n  'scientific-imrad': {\n    id: 'scientific-imrad',\n    name: 'Scientific Paper (IMRAD)',\n    description: 'Introduction, Methods, Results, Discussion structure for research papers',\n    domain: 'scientific',\n    tags: [\n      {\n        name: 'Introduction',\n        description: 'Background, context, and research question',\n        examples: [\n          'What is the research question?',\n          'Why is this important?',\n          'What is the hypothesis?'\n        ]\n      },\n      {\n        name: 'Methods',\n        description: 'Experimental design and procedures',\n        examples: [\n          'How was the study conducted?',\n          'What methods were used?',\n          'What was the experimental design?'\n        ]\n      },\n      {\n        name: 'Results',\n        description: 'Findings and observations',\n        examples: [\n          'What did the study find?',\n          'What are the data?',\n          'What were the observations?'\n        ]\n      },\n      {\n        name: 'Discussion',\n        description: 'Interpretation and implications of results',\n        examples: [\n          'What do the results mean?',\n          'What are the implications?',\n          'How do these findings relate to prior work?'\n        ]\n      }\n    ]\n  },\n\n  'argument-toulmin': {\n    id: 'argument-toulmin',\n    name: 'Argument Structure (Toulmin)',\n    description: 'Claim, Evidence, Warrant, Counterargument, Rebuttal framework for argumentation',\n    domain: 'general',\n    tags: [\n      {\n        name: 'Claim',\n        description: 'The main assertion or thesis',\n        examples: [\n          'What is being argued?',\n          'What is the main point?',\n          'What position is being taken?'\n        ]\n      },\n      {\n        name: 'Evidence',\n        description: 'Data or facts supporting the claim',\n        examples: [\n          'What supports this claim?',\n          'What are the facts?',\n          'What data is provided?'\n        ]\n      },\n      {\n        name: 'Warrant',\n        description: 'Reasoning connecting evidence to claim',\n        examples: [\n          'Why does this evidence support the claim?',\n          'What is the logic?',\n          'How does this reasoning work?'\n        ]\n      },\n      {\n        name: 'Counterargument',\n        description: 'Opposing viewpoints or objections',\n        examples: [\n          'What are the objections?',\n          'What do critics say?',\n          'What are alternative views?'\n        ]\n      },\n      {\n        name: 'Rebuttal',\n        description: 'Response to counterarguments',\n        examples: [\n          'How is the objection addressed?',\n          'Why is the counterargument wrong?',\n          'How is the criticism answered?'\n        ]\n      }\n    ]\n  }\n};\n\n/**\n * Get a tag schema by ID\n */\nexport function getTagSchema(schemaId: string): TagSchema | null {\n  return TAG_SCHEMAS[schemaId] || null;\n}\n\n/**\n * Get all available tag schemas\n */\nexport function getAllTagSchemas(): TagSchema[] {\n  return Object.values(TAG_SCHEMAS);\n}\n\n/**\n * Get tag schemas filtered by domain\n */\nexport function getTagSchemasByDomain(domain: 'legal' | 'scientific' | 'general'): TagSchema[] {\n  return Object.values(TAG_SCHEMAS).filter(schema => schema.domain === domain);\n}\n\n/**\n * Validate that a category name is valid for a schema\n */\nexport function isValidCategory(schemaId: string, categoryName: string): boolean {\n  const schema = getTagSchema(schemaId);\n  if (!schema) return false;\n  return schema.tags.some(tag => tag.name === categoryName);\n}\n\n/**\n * Get a specific category from a schema\n */\nexport function getSchemaCategory(schemaId: string, categoryName: string): TagCategory | null {\n  const schema = getTagSchema(schemaId);\n  if (!schema) return null;\n  return schema.tags.find(tag => tag.name === categoryName) || null;\n}\n","/**\n * Entity Type Extraction Utilities\n *\n * Extract entity types from annotation bodies.\n * Entity types are stored as TextualBody with purpose: \"tagging\"\n */\n\n\nimport type { Annotation } from '@semiont/core';\n\n/**\n * Extract entity types from annotation bodies\n * Entity types are stored as TextualBody with purpose: \"tagging\"\n * Accepts any object with a body property matching Annotation['body'].\n * Body is optional (highlights carry none) — returns [] if absent.\n */\nexport function getEntityTypes(annotation: { body?: Annotation['body'] }): string[] {\n  // Extract from TextualBody bodies with purpose: \"tagging\"\n  if (Array.isArray(annotation.body)) {\n    const entityTags: string[] = [];\n\n    for (const item of annotation.body) {\n      // Runtime check for TextualBody with tagging purpose\n      // TypeScript incorrectly narrows the union type here, so we use runtime checks only\n      if (\n        typeof item === 'object' &&\n        item !== null &&\n        'type' in item &&\n        'value' in item &&\n        'purpose' in item\n      ) {\n        // Access properties as unknown first to avoid TypeScript narrowing issues\n        const itemType = (item as { type: unknown }).type;\n        const itemValue = (item as { value: unknown }).value;\n        const itemPurpose = (item as { purpose: unknown }).purpose;\n\n        if (itemType === 'TextualBody' && itemPurpose === 'tagging' && typeof itemValue === 'string' && itemValue.length > 0) {\n          entityTags.push(itemValue);\n        }\n      }\n    }\n\n    return entityTags;\n  }\n\n  return [];\n}\n","/**\n * Tag Schema Extraction Utilities\n *\n * Extract tag categories and schema IDs from tag annotations.\n * Tags use dual-body structure:\n * - First body has purpose: \"tagging\" with category value\n * - Second body has purpose: \"classifying\" with schema ID\n */\n\n\nimport type { Annotation } from '@semiont/core';\n\n/**\n * Type guard to check if an annotation is a tag\n */\nfunction isTag(annotation: Annotation): boolean {\n  return annotation.motivation === 'tagging';\n}\n\n/**\n * Extract tag category from a tag annotation's body\n * Tags use dual-body structure: first body has purpose: \"tagging\" with category value\n * @param annotation - The annotation to extract category from\n * @returns The tag category (e.g., \"Issue\", \"Rule\"), or undefined if not a tag or no category found\n */\nexport function getTagCategory(annotation: Annotation): string | undefined {\n  if (!isTag(annotation)) return undefined;\n  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];\n  const taggingBody = bodies.find((b): b is Extract<typeof b, { purpose?: string }> =>\n    b !== null && typeof b === 'object' && 'purpose' in b && b.purpose === 'tagging'\n  );\n  if (taggingBody && 'value' in taggingBody) {\n    return taggingBody.value as string;\n  }\n  return undefined;\n}\n\n/**\n * Extract tag schema ID from a tag annotation's body\n * Tags use dual-body structure: second body has purpose: \"classifying\" with schema ID\n * @param annotation - The annotation to extract schema ID from\n * @returns The schema ID (e.g., \"legal-irac\"), or undefined if not a tag or no schema found\n */\nexport function getTagSchemaId(annotation: Annotation): string | undefined {\n  if (!isTag(annotation)) return undefined;\n  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];\n  const classifyingBody = bodies.find((b): b is Extract<typeof b, { purpose?: string }> =>\n    b !== null && typeof b === 'object' && 'purpose' in b && b.purpose === 'classifying'\n  );\n  if (classifyingBody && 'value' in classifyingBody) {\n    return classifyingBody.value as string;\n  }\n  return undefined;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/entity-types.ts","../src/entity-extraction.ts","../src/tag-extraction.ts"],"sourcesContent":["/**\n * Default entity types for the Semiont system\n *\n * Entity types are used to tag resources and annotations with semantic categories.\n * These types serve as initial seed data for the entity types collection.\n */\nexport const DEFAULT_ENTITY_TYPES = [\n  'Person',\n  'Organization',\n  'Location',\n  'Event',\n  'Concept',\n  'Product',\n  'Technology',\n  'Date',\n  'Author'\n];\n","/**\n * Entity Type Extraction Utilities\n *\n * Extract entity types from annotation bodies.\n * Entity types are stored as TextualBody with purpose: \"tagging\"\n */\n\n\nimport type { Annotation } from '@semiont/core';\n\n/**\n * Extract entity types from annotation bodies\n * Entity types are stored as TextualBody with purpose: \"tagging\"\n * Accepts any object with a body property matching Annotation['body'].\n * Body is optional (highlights carry none) — returns [] if absent.\n */\nexport function getEntityTypes(annotation: { body?: Annotation['body'] }): string[] {\n  // Extract from TextualBody bodies with purpose: \"tagging\"\n  if (Array.isArray(annotation.body)) {\n    const entityTags: string[] = [];\n\n    for (const item of annotation.body) {\n      // Runtime check for TextualBody with tagging purpose\n      // TypeScript incorrectly narrows the union type here, so we use runtime checks only\n      if (\n        typeof item === 'object' &&\n        item !== null &&\n        'type' in item &&\n        'value' in item &&\n        'purpose' in item\n      ) {\n        // Access properties as unknown first to avoid TypeScript narrowing issues\n        const itemType = (item as { type: unknown }).type;\n        const itemValue = (item as { value: unknown }).value;\n        const itemPurpose = (item as { purpose: unknown }).purpose;\n\n        if (itemType === 'TextualBody' && itemPurpose === 'tagging' && typeof itemValue === 'string' && itemValue.length > 0) {\n          entityTags.push(itemValue);\n        }\n      }\n    }\n\n    return entityTags;\n  }\n\n  return [];\n}\n","/**\n * Tag Schema Extraction Utilities\n *\n * Extract tag categories and schema IDs from tag annotations.\n * Tags use dual-body structure:\n * - First body has purpose: \"tagging\" with category value\n * - Second body has purpose: \"classifying\" with schema ID\n */\n\n\nimport type { Annotation } from '@semiont/core';\n\n/**\n * Type guard to check if an annotation is a tag\n */\nfunction isTag(annotation: Annotation): boolean {\n  return annotation.motivation === 'tagging';\n}\n\n/**\n * Extract tag category from a tag annotation's body\n * Tags use dual-body structure: first body has purpose: \"tagging\" with category value\n * @param annotation - The annotation to extract category from\n * @returns The tag category (e.g., \"Issue\", \"Rule\"), or undefined if not a tag or no category found\n */\nexport function getTagCategory(annotation: Annotation): string | undefined {\n  if (!isTag(annotation)) return undefined;\n  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];\n  const taggingBody = bodies.find((b): b is Extract<typeof b, { purpose?: string }> =>\n    b !== null && typeof b === 'object' && 'purpose' in b && b.purpose === 'tagging'\n  );\n  if (taggingBody && 'value' in taggingBody) {\n    return taggingBody.value as string;\n  }\n  return undefined;\n}\n\n/**\n * Extract tag schema ID from a tag annotation's body\n * Tags use dual-body structure: second body has purpose: \"classifying\" with schema ID\n * @param annotation - The annotation to extract schema ID from\n * @returns The schema ID (e.g., \"legal-irac\"), or undefined if not a tag or no schema found\n */\nexport function getTagSchemaId(annotation: Annotation): string | undefined {\n  if (!isTag(annotation)) return undefined;\n  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];\n  const classifyingBody = bodies.find((b): b is Extract<typeof b, { purpose?: string }> =>\n    b !== null && typeof b === 'object' && 'purpose' in b && b.purpose === 'classifying'\n  );\n  if (classifyingBody && 'value' in classifyingBody) {\n    return classifyingBody.value as string;\n  }\n  return undefined;\n}\n"],"mappings":";AAMO,IAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;;;ACAO,SAAS,eAAe,YAAqD;AAElF,MAAI,MAAM,QAAQ,WAAW,IAAI,GAAG;AAClC,UAAM,aAAuB,CAAC;AAE9B,eAAW,QAAQ,WAAW,MAAM;AAGlC,UACE,OAAO,SAAS,YAChB,SAAS,QACT,UAAU,QACV,WAAW,QACX,aAAa,MACb;AAEA,cAAM,WAAY,KAA2B;AAC7C,cAAM,YAAa,KAA4B;AAC/C,cAAM,cAAe,KAA8B;AAEnD,YAAI,aAAa,iBAAiB,gBAAgB,aAAa,OAAO,cAAc,YAAY,UAAU,SAAS,GAAG;AACpH,qBAAW,KAAK,SAAS;AAAA,QAC3B;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,CAAC;AACV;;;AC/BA,SAAS,MAAM,YAAiC;AAC9C,SAAO,WAAW,eAAe;AACnC;AAQO,SAAS,eAAe,YAA4C;AACzE,MAAI,CAAC,MAAM,UAAU,EAAG,QAAO;AAC/B,QAAM,SAAS,MAAM,QAAQ,WAAW,IAAI,IAAI,WAAW,OAAO,CAAC,WAAW,IAAI;AAClF,QAAM,cAAc,OAAO;AAAA,IAAK,CAAC,MAC/B,MAAM,QAAQ,OAAO,MAAM,YAAY,aAAa,KAAK,EAAE,YAAY;AAAA,EACzE;AACA,MAAI,eAAe,WAAW,aAAa;AACzC,WAAO,YAAY;AAAA,EACrB;AACA,SAAO;AACT;AAQO,SAAS,eAAe,YAA4C;AACzE,MAAI,CAAC,MAAM,UAAU,EAAG,QAAO;AAC/B,QAAM,SAAS,MAAM,QAAQ,WAAW,IAAI,IAAI,WAAW,OAAO,CAAC,WAAW,IAAI;AAClF,QAAM,kBAAkB,OAAO;AAAA,IAAK,CAAC,MACnC,MAAM,QAAQ,OAAO,MAAM,YAAY,aAAa,KAAK,EAAE,YAAY;AAAA,EACzE;AACA,MAAI,mBAAmB,WAAW,iBAAiB;AACjD,WAAO,gBAAgB;AAAA,EACzB;AACA,SAAO;AACT;","names":[]}

package/dist/tag-collections.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Tag Collections Management
+ *
+ * Stores entity types in the graph database as append-only collections.
+ * Provides interface for graph database implementations to manage entity type collections.
+ */
+export interface TagCollection {
+    id: string;
+    collectionType: 'entity-types';
+    tags: string[];
+    created: Date;
+    updatedAt: Date;
+}
+export interface TagCollectionOperations {
+    /**
+     * Get or create collections with auto-seeding
+     */
+    getEntityTypes(): Promise<string[]>;
+    /**
+     * Append new tag (no duplicates)
+     */
+    addEntityType(tag: string): Promise<void>;
+    /**
+     * Bulk append tags
+     */
+    addEntityTypes(tags: string[]): Promise<void>;
+    /**
+     * Check if collections exist
+     */
+    hasEntityTypesCollection(): Promise<boolean>;
+    /**
+     * Initialize collections with seed data if they don't exist
+     */
+    initializeCollections(): Promise<void>;
+}
+//# sourceMappingURL=tag-collections.d.ts.map

package/dist/tag-collections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-collections.d.ts","sourceRoot":"","sources":["../src/tag-collections.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,cAAc,CAAC;IAC/B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEpC;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1C;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9C;;OAEG;IACH,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7C;;OAEG;IACH,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC"}

package/dist/tag-extraction.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tag Schema Extraction Utilities
+ *
+ * Extract tag categories and schema IDs from tag annotations.
+ * Tags use dual-body structure:
+ * - First body has purpose: "tagging" with category value
+ * - Second body has purpose: "classifying" with schema ID
+ */
+import type { Annotation } from '@semiont/core';
+/**
+ * Extract tag category from a tag annotation's body
+ * Tags use dual-body structure: first body has purpose: "tagging" with category value
+ * @param annotation - The annotation to extract category from
+ * @returns The tag category (e.g., "Issue", "Rule"), or undefined if not a tag or no category found
+ */
+export declare function getTagCategory(annotation: Annotation): string | undefined;
+/**
+ * Extract tag schema ID from a tag annotation's body
+ * Tags use dual-body structure: second body has purpose: "classifying" with schema ID
+ * @param annotation - The annotation to extract schema ID from
+ * @returns The schema ID (e.g., "legal-irac"), or undefined if not a tag or no schema found
+ */
+export declare function getTagSchemaId(annotation: Annotation): string | undefined;
+//# sourceMappingURL=tag-extraction.d.ts.map

package/dist/tag-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-extraction.d.ts","sourceRoot":"","sources":["../src/tag-extraction.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAShD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAUzE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAUzE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semiont/ontology",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "type": "module",
   "description": "Entity types, tag schemas, and W3C annotation vocabularies",
   "main": "./dist/index.js",
@@ -16,7 +16,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "npm run typecheck && tsup",
+    "build": "npm run typecheck && tsup && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
     "test": "vitest run",
@@ -27,7 +27,7 @@
   "devDependencies": {
     "@vitest/coverage-v8": "^4.1.0",
     "tsup": "^8.0.1",
-    "typescript": "^5.6.3"
+    "typescript": "^6.0.2"
   },
   "publishConfig": {
     "access": "public"