@semiont/core 0.5.3 → 0.5.4

package/dist/event-base.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Event Base Types
+ *
+ * Core shapes for the event-sourced persistence model.
+ * EventBase is the common shape for all domain events.
+ * StoredEvent wraps an event with persistence metadata.
+ *
+ * These types are referenced by event-catalog.ts (domain events)
+ * and bus-protocol.ts (the full EventMap).
+ */
+import type { components } from './types';
+import type { ResourceId, UserId } from './identifiers';
+import type { PersistedEvent } from './persisted-events';
+/**
+ * Narrow an OpenAPI-generated type by overriding specific fields with branded types.
+ *
+ * OpenAPI schemas use plain `string` for identifiers. TypeScript branded types
+ * (ResourceId, AnnotationId, UserId, JobId) add compile-time safety. Brand<T, B>
+ * takes the OpenAPI type T and replaces the fields listed in B with their branded
+ * counterparts, preserving all other fields from the schema.
+ *
+ * @example
+ * type MyCommand = Brand<components['schemas']['YieldCreateCommand'], { userId: UserId }>;
+ * // Result: YieldCreateCommand with userId narrowed from string to UserId
+ */
+export type Brand<T, Overrides> = Omit<T, keyof Overrides> & Overrides;
+/** Fields common to ALL domain events (system and resource-scoped). */
+export interface EventBase {
+    id: string;
+    timestamp: string;
+    resourceId?: ResourceId;
+    userId: UserId;
+    version: number;
+}
+/** Persistence metadata attached to every stored event. */
+export type EventMetadata = components['schemas']['EventMetadata'];
+/** Optional cryptographic signature on a stored event. */
+export interface EventSignature {
+    algorithm: 'ed25519';
+    publicKey: string;
+    signature: string;
+    keyId?: string;
+}
+/**
+ * A domain event with persistence metadata.
+ * Flat intersection — no nesting (event.type, not event.event.type).
+ */
+export type StoredEvent<T extends EventBase = PersistedEvent> = T & {
+    metadata: EventMetadata;
+    signature?: EventSignature;
+};
+export type BodyItem = components['schemas']['TextualBody'] | components['schemas']['SpecificResource'];
+export type BodyOperation = components['schemas']['BodyOperationAdd'] | components['schemas']['BodyOperationRemove'] | components['schemas']['BodyOperationReplace'];
+import type { Annotation } from './annotation-types';
+export interface EventQuery {
+    resourceId?: ResourceId;
+    userId?: string;
+    eventTypes?: string[];
+    fromTimestamp?: string;
+    toTimestamp?: string;
+    fromSequence?: number;
+    limit?: number;
+}
+export interface ResourceAnnotations {
+    resourceId: ResourceId;
+    annotations: Annotation[];
+    version: number;
+    updatedAt: string;
+}
+//# sourceMappingURL=event-base.d.ts.map

package/dist/event-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-base.d.ts","sourceRoot":"","sources":["../src/event-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAIzD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,SAAS,IAC5B,IAAI,CAAC,CAAC,EAAE,MAAM,SAAS,CAAC,GAAG,SAAS,CAAC;AAIvC,uEAAuE;AACvE,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,2DAA2D;AAC3D,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,eAAe,CAAC,CAAC;AAEnE,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAID;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,GAAG,cAAc,IAAI,CAAC,GAAG;IAClE,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B,CAAC;AAIF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,aAAa,CAAC,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAAC;AAExG,MAAM,MAAM,aAAa,GACrB,UAAU,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,GACzC,UAAU,CAAC,SAAS,CAAC,CAAC,qBAAqB,CAAC,GAC5C,UAAU,CAAC,SAAS,CAAC,CAAC,sBAAsB,CAAC,CAAC;AAIlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,WAAW,UAAU;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/event-bus.d.ts

@@ -0,0 +1,141 @@
+/**
+ * RxJS-based Event Bus
+ *
+ * Framework-agnostic event bus providing direct access to typed RxJS Subjects.
+ *
+ * Can be used in Node.js, browser, workers, CLI - anywhere RxJS runs.
+ */
+import { Subject } from 'rxjs';
+import type { EventMap } from './bus-protocol';
+import type { StoredEvent } from './event-base';
+import type { PersistedEventType } from './persisted-events';
+/**
+ * RxJS-based event bus
+ *
+ * Provides direct access to RxJS Subjects for each event type.
+ * Use standard RxJS patterns for emitting and subscribing.
+ *
+ * @example
+ * ```typescript
+ * const eventBus = new EventBus();
+ *
+ * // Emit events
+ * eventBus.get('beckon:hover').next({ annotationId: 'ann-1' });
+ *
+ * // Subscribe to events
+ * const subscription = eventBus.get('beckon:hover').subscribe(({ annotationId }) => {
+ *   console.log('Hover:', annotationId);
+ * });
+ *
+ * // Use RxJS operators
+ * import { debounceTime } from 'rxjs/operators';
+ * eventBus.get('beckon:hover')
+ *   .pipe(debounceTime(100))
+ *   .subscribe(handleHover);
+ *
+ * // Cleanup
+ * subscription.unsubscribe();
+ * eventBus.destroy();
+ * ```
+ */
+export declare class EventBus {
+    private subjects;
+    private isDestroyed;
+    constructor();
+    /**
+     * Get the RxJS Subject for an event
+     *
+     * Returns a typed Subject that can be used with all RxJS operators.
+     * Subjects are created lazily on first access.
+     *
+     * @param eventName - The event name
+     * @returns The RxJS Subject for this event
+     *
+     * @example
+     * ```typescript
+     * // Emit
+     * eventBus.get('beckon:hover').next({ annotationId: 'ann-1' });
+     *
+     * // Subscribe
+     * const sub = eventBus.get('beckon:hover').subscribe(handleHover);
+     *
+     * // With operators
+     * eventBus.get('beckon:hover')
+     *   .pipe(debounceTime(100), distinctUntilChanged())
+     *   .subscribe(handleHover);
+     * ```
+     */
+    get<K extends keyof EventMap>(eventName: K): Subject<EventMap[K]>;
+    /**
+     * Get the RxJS Subject for a domain event type (PersistedEventType).
+     *
+     * Domain event channels carry `StoredEvent`. This method avoids the need
+     * for `as keyof EventMap` casts when subscribing to domain event channels
+     * using runtime `PersistedEventType` strings.
+     */
+    getDomainEvent(eventType: PersistedEventType): Subject<StoredEvent>;
+    /**
+     * Destroy the event bus and complete all subjects
+     *
+     * After calling destroy(), no new events can be emitted or subscribed to.
+     * All active subscriptions will be completed.
+     */
+    destroy(): void;
+    /**
+     * Check if the event bus has been destroyed
+     */
+    get destroyed(): boolean;
+    /**
+     * Create a resource-scoped event bus
+     *
+     * Events emitted or subscribed through the scoped bus are isolated to that resource.
+     * Internally, events are namespaced but the API remains identical to the parent bus.
+     *
+     * @param resourceId - Resource identifier to scope events to
+     * @returns A scoped event bus for this resource
+     *
+     * @example
+     * ```typescript
+     * const eventBus = new EventBus();
+     * const resource1 = eventBus.scope('resource-1');
+     * const resource2 = eventBus.scope('resource-2');
+     *
+     * // These are isolated - only resource1 subscribers will fire
+     * resource1.get('detection:progress').next({ status: 'started' });
+     * ```
+     */
+    scope(resourceId: string): ScopedEventBus;
+}
+/**
+ * Resource-scoped event bus
+ *
+ * Provides isolated event streams per resource while maintaining the same API
+ * as the parent EventBus. Events are internally namespaced by resourceId.
+ */
+export declare class ScopedEventBus {
+    private parent;
+    private scopePrefix;
+    constructor(parent: EventBus, scopePrefix: string);
+    /**
+     * Get the RxJS Subject for a scoped event
+     *
+     * Returns the same type as the parent bus, but events are isolated to this scope.
+     * Internally uses namespaced keys but preserves type safety.
+     *
+     * @param event - The event name
+     * @returns The RxJS Subject for this scoped event
+     */
+    get<E extends keyof EventMap>(event: E): Subject<EventMap[E]>;
+    /** Get the RxJS Subject for a domain event type on this scoped bus. */
+    getDomainEvent(eventType: PersistedEventType): Subject<StoredEvent>;
+    /**
+     * Create a nested scope
+     *
+     * Allows hierarchical scoping like `resource-1:subsystem-a`
+     *
+     * @param subScope - Additional scope level
+     * @returns A nested scoped event bus
+     */
+    scope(subScope: string): ScopedEventBus;
+}
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../src/event-bus.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,WAAW,CAAU;;IAO7B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,SAAS,EAAE,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IA+BjE;;;;;;OAMG;IACH,cAAc,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC;IAInE;;;;;OAKG;IACH,OAAO,IAAI,IAAI;IAaf;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc;CAG1C;AAED;;;;;GAKG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,WAAW;gBADX,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,MAAM;IAG7B;;;;;;;;OAQG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAa7D,uEAAuE;IACvE,cAAc,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC;IAInE;;;;;;;OAOG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc;CAGxC"}

package/dist/event-utils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Event Type Guards and Extraction Utilities
+ *
+ * Domain logic for working with resource events.
+ * No React dependencies - safe to use in any JavaScript environment.
+ */
+import type { StoredEvent } from './event-base';
+import type { AnnotationUri } from './branded-types';
+/**
+ * Minimal event shape accepted by event utility functions.
+ * Compatible with both the internal `StoredEvent` type and the OpenAPI-derived
+ * schema type (`GetEventsResponse['events'][number]`), which lacks `version`.
+ *
+ * Flat shape — event fields and metadata are peers (no `event` wrapper).
+ */
+export interface StoredEventLike {
+    id: string;
+    type: string;
+    timestamp: string;
+    userId: string;
+    resourceId?: string;
+    payload?: unknown;
+    metadata: {
+        sequenceNumber: number;
+    };
+}
+/**
+ * Extract annotation ID from event payload
+ * Returns null if event is not annotation-related
+ *
+ * For mark:added: extracts full URI from payload.annotation.id
+ * For mark:removed/mark:body-updated: constructs full URI from payload.annotationId (UUID) + resourceId
+ */
+export declare function getAnnotationUriFromEvent(event: StoredEventLike): AnnotationUri | null;
+/**
+ * Check if an event is related to a specific annotation
+ */
+export declare function isEventRelatedToAnnotation(event: StoredEventLike, annotationUri: AnnotationUri): boolean;
+/**
+ * Type guard to check if an object is a StoredEvent (flat shape)
+ */
+export declare function isStoredEvent(event: any): event is StoredEvent;
+//# sourceMappingURL=event-utils.d.ts.map

package/dist/event-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-utils.d.ts","sourceRoot":"","sources":["../src/event-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE;QACR,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AAMD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,eAAe,GAAG,aAAa,GAAG,IAAI,CAoBtF;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,GAAG,OAAO,CAGxG;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,WAAW,CAO9D"}

package/dist/fuzzy-anchor.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Fuzzy Anchoring for W3C Web Annotation TextQuoteSelector
+ *
+ * Uses prefix/suffix context to disambiguate when the same text appears multiple times.
+ * Implements fuzzy matching as specified in the W3C Web Annotation Data Model.
+ *
+ * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
+ */
+export interface TextPosition {
+    start: number;
+    end: number;
+}
+export type MatchQuality = 'exact' | 'normalized' | 'case-insensitive' | 'fuzzy';
+/**
+ * Normalize text for comparison - handles common document editing changes
+ *
+ * Collapses whitespace, converts curly quotes to straight quotes,
+ * and normalizes common punctuation variations.
+ */
+export declare function normalizeText(text: string): string;
+/**
+ * Pre-computed content strings for batch fuzzy matching.
+ * Avoids recomputing normalizeText(content) and content.toLowerCase()
+ * for every annotation when processing many annotations against the same content.
+ */
+export interface ContentCache {
+    normalizedContent: string;
+    lowerContent: string;
+}
+/**
+ * Build a ContentCache for a given content string.
+ * Call once per content, pass to findBestTextMatch/findTextWithContext for all annotations.
+ */
+export declare function buildContentCache(content: string): ContentCache;
+/**
+ * Find best match for text in content using multi-strategy search
+ *
+ * Shared core logic used by both findTextWithContext and validateAndCorrectOffsets.
+ *
+ * @param content - Full text content to search within
+ * @param searchText - The text to find
+ * @param positionHint - Hint for where to search (TextPositionSelector.start)
+ * @param cache - Pre-computed normalized/lowered content (from buildContentCache)
+ * @returns Match with position and quality, or null if not found
+ */
+export declare function findBestTextMatch(content: string, searchText: string, positionHint: number | undefined, cache: ContentCache): {
+    start: number;
+    end: number;
+    matchQuality: MatchQuality;
+} | null;
+/**
+ * Find text using exact match with optional prefix/suffix context
+ *
+ * When the exact text appears multiple times in the content, prefix and suffix
+ * are used to disambiguate and find the correct occurrence.
+ *
+ * If exact text is not found, uses multi-strategy fuzzy matching (normalization,
+ * case-insensitive, Levenshtein distance) to locate changed text.
+ *
+ * @param content - Full text content to search within
+ * @param exact - The exact text to find
+ * @param prefix - Optional text that should appear immediately before the match
+ * @param suffix - Optional text that should appear immediately after the match
+ * @param positionHint - Optional position hint (from TextPositionSelector) for fuzzy search
+ * @returns Position of the matched text, or null if not found
+ *
+ * @example
+ * ```typescript
+ * const content = "The cat sat. The cat ran.";
+ * // Find second "The cat" occurrence
+ * const pos = findTextWithContext(content, "The cat", "sat. ", " ran");
+ * // Returns { start: 13, end: 20 }
+ * ```
+ */
+export declare function findTextWithContext(content: string, exact: string, prefix: string | undefined, suffix: string | undefined, positionHint: number | undefined, cache: ContentCache): TextPosition | null;
+/**
+ * Verify that a position correctly points to the exact text
+ * Useful for debugging and validation
+ */
+export declare function verifyPosition(content: string, position: TextPosition, expectedExact: string): boolean;
+//# sourceMappingURL=fuzzy-anchor.d.ts.map

package/dist/fuzzy-anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy-anchor.d.ts","sourceRoot":"","sources":["../src/fuzzy-anchor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,YAAY,GAAG,kBAAkB,GAAG,OAAO,CAAC;AAEjF;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQlD;AAiCD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAK/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,KAAK,EAAE,YAAY,GAClB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAE,GAAG,IAAI,CAgFnE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,KAAK,EAAE,YAAY,GAClB,YAAY,GAAG,IAAI,CA2ErB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,YAAY,EACtB,aAAa,EAAE,MAAM,GACpB,OAAO,CAGT"}

package/dist/graph.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Graph types - Models for graph connections and relationships
+ */
+import type { components } from './types';
+import type { ResourceId } from './identifiers';
+import type { Annotation } from './annotation-types';
+type RawResourceDescriptor = components['schemas']['ResourceDescriptor'];
+/**
+ * Domain-level ResourceDescriptor type. Same shape as the OpenAPI-generated
+ * `components['schemas']['ResourceDescriptor']`, but with a branded `ResourceId`
+ * for the `@id` field.
+ *
+ * Implemented by intersection (not `Omit`) because the generated raw type
+ * ends in `& { [key: string]: unknown }` — `Omit` on an intersection with
+ * an index signature drops almost all named fields.
+ */
+export type ResourceDescriptor = RawResourceDescriptor & {
+    '@id': ResourceId;
+};
+/**
+ * Represents a connection between resources through annotations
+ */
+export interface GraphConnection {
+    targetResource: ResourceDescriptor;
+    annotations: Annotation[];
+    relationshipType?: string;
+    bidirectional: boolean;
+}
+/**
+ * Represents a path through the graph
+ */
+export interface GraphPath {
+    resources: ResourceDescriptor[];
+    annotations: Annotation[];
+}
+/**
+ * Statistics about entity types in the graph
+ */
+export interface EntityTypeStats {
+    type: string;
+    count: number;
+}
+export {};
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,KAAK,qBAAqB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,oBAAoB,CAAC,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,qBAAqB,GAAG;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,kBAAkB,CAAC;IACnC,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/id-generation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ID generation utilities
+ */
+/**
+ * Generate a UUID v4 string (without dashes)
+ */
+export declare function generateUuid(): string;
+//# sourceMappingURL=id-generation.d.ts.map

package/dist/id-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-generation.d.ts","sourceRoot":"","sources":["../src/id-generation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAErC"}

package/dist/identifiers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Branded identifier types for compile-time type safety.
+ *
+ * These types prevent mixing up resource IDs, annotation IDs, and user IDs
+ * at compile time while having zero runtime overhead.
+ *
+ * URI types (ResourceUri, AnnotationUri) are in @semiont/api-client
+ * since they deal with HTTP URIs returned by the API.
+ */
+export type ResourceId = string & {
+    readonly __brand: 'ResourceId';
+};
+export type AnnotationId = string & {
+    readonly __brand: 'AnnotationId';
+};
+export type UserId = string & {
+    readonly __brand: 'UserId';
+};
+export declare function isResourceId(value: string): value is ResourceId;
+export declare function isAnnotationId(value: string): value is AnnotationId;
+export declare function resourceId(id: string): ResourceId;
+export declare function annotationId(id: string): AnnotationId;
+export declare function userId(id: string): UserId;
+//# sourceMappingURL=identifiers.d.ts.map

package/dist/identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../src/identifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AACrE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;CAAE,CAAC;AACzE,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;AAG7D,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAE/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAEnE;AAGD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAKjD;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAKrD;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzC"}