@plures/praxis 0.2.1 → 1.0.1

package/dist/src/core/pluresdb/schema-registry.js

@@ -0,0 +1,130 @@
+/**
+ * Praxis Schema Registry for PluresDB
+ *
+ * Registers Praxis schema definitions in PluresDB for type-safe storage
+ * and cross-agent schema discovery.
+ */
+import { PRAXIS_PATHS } from "./store.js";
+/**
+ * Get the path for a schema in PluresDB
+ * @param schemaName The schema name
+ */
+export function getSchemaPath(schemaName) {
+    return `${PRAXIS_PATHS.SCHEMAS}/${schemaName}`;
+}
+/**
+ * PraxisSchemaRegistry
+ *
+ * Manages schema definitions in PluresDB.
+ * Schemas are stored under `/_praxis/schemas/<schemaName>`
+ */
+export class PraxisSchemaRegistry {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Register a schema in PluresDB
+     *
+     * @param schema The schema to register
+     */
+    async register(schema) {
+        const path = getSchemaPath(schema.name);
+        const storedSchema = {
+            schema,
+            registeredAt: Date.now(),
+            version: schema.version,
+        };
+        await this.db.set(path, storedSchema);
+    }
+    /**
+     * Get a schema by name
+     *
+     * @param schemaName The schema name
+     * @returns The stored schema or undefined if not found
+     */
+    async get(schemaName) {
+        const path = getSchemaPath(schemaName);
+        return this.db.get(path);
+    }
+    /**
+     * Check if a schema is registered
+     *
+     * @param schemaName The schema name
+     * @returns True if the schema exists
+     */
+    async exists(schemaName) {
+        const stored = await this.get(schemaName);
+        return stored !== undefined;
+    }
+    /**
+     * Update a schema (replaces existing)
+     *
+     * @param schema The updated schema
+     */
+    async update(schema) {
+        await this.register(schema);
+    }
+    /**
+     * List all registered schema names
+     *
+     * Implementation note: This method uses an index stored at `/_praxis/schemas/_index`.
+     * When using InMemoryPraxisDB, schemas must be registered using `registerWithIndex()`
+     * for them to appear in this listing. When using a full PluresDB implementation,
+     * native listing capabilities should be used instead.
+     *
+     * @returns Array of registered schema names
+     */
+    async list() {
+        const indexPath = `${PRAXIS_PATHS.SCHEMAS}/_index`;
+        const index = await this.db.get(indexPath);
+        return index ?? [];
+    }
+    /**
+     * Register a schema and update the index
+     *
+     * @param schema The schema to register
+     */
+    async registerWithIndex(schema) {
+        // Register the schema
+        await this.register(schema);
+        // Update the index
+        const indexPath = `${PRAXIS_PATHS.SCHEMAS}/_index`;
+        const existingIndex = await this.db.get(indexPath) ?? [];
+        if (!existingIndex.includes(schema.name)) {
+            await this.db.set(indexPath, [...existingIndex, schema.name]);
+        }
+    }
+}
+/**
+ * Register a schema in PluresDB
+ *
+ * Convenience function for one-off schema registration.
+ *
+ * @param db The PraxisDB instance
+ * @param schema The schema to register
+ *
+ * @example
+ * ```typescript
+ * const db = createInMemoryDB();
+ * await registerSchema(db, {
+ *   version: "1.0.0",
+ *   name: "MyApp",
+ *   description: "My application schema"
+ * });
+ * ```
+ */
+export async function registerSchema(db, schema) {
+    const registry = new PraxisSchemaRegistry(db);
+    await registry.registerWithIndex(schema);
+}
+/**
+ * Create a PraxisSchemaRegistry instance
+ *
+ * @param db The PraxisDB instance
+ * @returns PraxisSchemaRegistry instance
+ */
+export function createSchemaRegistry(db) {
+    return new PraxisSchemaRegistry(db);
+}
+//# sourceMappingURL=schema-registry.js.map

package/dist/src/core/pluresdb/schema-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-registry.js","sourceRoot":"","sources":["../../../../src/core/pluresdb/schema-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,UAAkB;IAC9C,OAAO,GAAG,YAAY,CAAC,OAAO,IAAI,UAAU,EAAE,CAAC;AACjD,CAAC;AAcD;;;;;GAKG;AACH,MAAM,OAAO,oBAAoB;IACvB,EAAE,CAAW;IAErB,YAAY,EAAY;QACtB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,QAAQ,CAAC,MAAoB;QACjC,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAExC,MAAM,YAAY,GAAiB;YACjC,MAAM;YACN,YAAY,EAAE,IAAI,CAAC,GAAG,EAAE;YACxB,OAAO,EAAE,MAAM,CAAC,OAAO;SACxB,CAAC;QAEF,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,GAAG,CAAC,UAAkB;QAC1B,MAAM,IAAI,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC,EAAE,CAAC,GAAG,CAAe,IAAI,CAAC,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,UAAkB;QAC7B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC1C,OAAO,MAAM,KAAK,SAAS,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,MAAoB;QAC/B,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,IAAI;QACR,MAAM,SAAS,GAAG,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC;QACnD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAW,SAAS,CAAC,CAAC;QACrD,OAAO,KAAK,IAAI,EAAE,CAAC;IACrB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iBAAiB,CAAC,MAAoB;QAC1C,sBAAsB;QACtB,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE5B,mBAAmB;QACnB,MAAM,SAAS,GAAG,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC;QACnD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAW,SAAS,CAAC,IAAI,EAAE,CAAC;QAEnE,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,GAAG,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,EAAY,EACZ,MAAoB;IAEpB,MAAM,QAAQ,GAAG,IAAI,oBAAoB,CAAC,EAAE,CAAC,CAAC;IAC9C,MAAM,QAAQ,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,EAAY;IAC/C,OAAO,IAAI,oBAAoB,CAAC,EAAE,CAAC,CAAC;AACtC,CAAC"}

package/dist/src/core/pluresdb/store.d.ts

@@ -0,0 +1,199 @@
+/**
+ * PraxisDB Store
+ *
+ * Connects Praxis Facts, Events, Rules, and Constraints to PluresDB.
+ * Provides CRDT-backed storage for facts and append-only event streams.
+ */
+import type { PraxisDB, UnsubscribeFn } from "./adapter.js";
+import type { PraxisRegistry } from "../rules.js";
+import type { PraxisFact, PraxisEvent } from "../protocol.js";
+/**
+ * Key paths for Praxis data in PluresDB
+ */
+export declare const PRAXIS_PATHS: {
+    /** Base path for all Praxis data */
+    readonly BASE: "/_praxis";
+    /** Path for facts storage */
+    readonly FACTS: "/_praxis/facts";
+    /** Path for events storage */
+    readonly EVENTS: "/_praxis/events";
+    /** Path for schema registry */
+    readonly SCHEMAS: "/_praxis/schemas";
+};
+/**
+ * Generate a fact key path
+ * @param factTag The fact type tag
+ * @param id Optional unique identifier for the fact instance
+ */
+export declare function getFactPath(factTag: string, id?: string): string;
+/**
+ * Generate an event stream key path
+ * @param eventTag The event type tag
+ */
+export declare function getEventPath(eventTag: string): string;
+/**
+ * Generate a unique ID for facts or events
+ * Uses timestamp and random string for uniqueness
+ */
+export declare function generateId(): string;
+/**
+ * Event stream entry with timestamp
+ */
+export interface EventStreamEntry {
+    /** The event data */
+    event: PraxisEvent;
+    /** Timestamp when the event was appended */
+    timestamp: number;
+    /** Optional sequence number */
+    sequence?: number;
+}
+/**
+ * Options for creating a PraxisDBStore
+ */
+export interface PraxisDBStoreOptions<TContext = unknown> {
+    /** The PraxisDB instance to use */
+    db: PraxisDB;
+    /** The PraxisRegistry for rules and constraints */
+    registry: PraxisRegistry<TContext>;
+    /** Initial context for rule evaluation */
+    initialContext?: TContext;
+}
+/**
+ * PraxisDBStore
+ *
+ * Manages persistence and reactive updates for Praxis state in PluresDB.
+ *
+ * - Facts are stored as CRDT-backed documents under `/_praxis/facts/<factTag>/<id>`
+ * - Events are stored as append-only streams under `/_praxis/events/<eventTag>`
+ * - Rules are triggered automatically when watched keys change
+ * - Constraints are run before writing mutated state
+ */
+/**
+ * Error handler callback for rule execution errors
+ */
+export type RuleErrorHandler = (ruleId: string, error: unknown) => void;
+export declare class PraxisDBStore<TContext = unknown> {
+    private db;
+    private registry;
+    private context;
+    private subscriptions;
+    private factWatchers;
+    private onRuleError;
+    constructor(options: PraxisDBStoreOptions<TContext> & {
+        onRuleError?: RuleErrorHandler;
+    });
+    /**
+     * Store a fact in PluresDB
+     *
+     * Facts are stored under `/_praxis/facts/<factTag>/<id>`
+     * If no id is provided in the payload, a timestamp-based id is used.
+     *
+     * @param fact The fact to store
+     * @returns Promise that resolves when the fact is stored
+     */
+    storeFact(fact: PraxisFact): Promise<void>;
+    /**
+     * Store multiple facts in PluresDB
+     *
+     * @param facts The facts to store
+     */
+    storeFacts(facts: PraxisFact[]): Promise<void>;
+    /**
+     * Internal method to persist a fact without constraint checking
+     * Used by both storeFact and derived fact storage
+     */
+    private persistFact;
+    /**
+     * Get a fact by tag and id
+     *
+     * @param factTag The fact type tag
+     * @param id The fact id
+     * @returns The fact or undefined if not found
+     */
+    getFact(factTag: string, id: string): Promise<PraxisFact | undefined>;
+    /**
+     * Append an event to the event stream
+     *
+     * Events are stored as append-only streams under `/_praxis/events/<eventTag>`
+     *
+     * @param event The event to append
+     */
+    appendEvent(event: PraxisEvent): Promise<void>;
+    /**
+     * Append multiple events to their respective streams
+     *
+     * @param events The events to append
+     */
+    appendEvents(events: PraxisEvent[]): Promise<void>;
+    /**
+     * Get events from a stream
+     *
+     * @param eventTag The event type tag
+     * @param options Query options
+     * @returns Array of event stream entries
+     */
+    getEvents(eventTag: string, options?: {
+        since?: number;
+        limit?: number;
+    }): Promise<EventStreamEntry[]>;
+    /**
+     * Watch a fact path for changes
+     *
+     * @param factTag The fact type tag to watch
+     * @param callback Called when facts of this type change
+     * @returns Unsubscribe function
+     */
+    watchFacts(factTag: string, callback: (facts: PraxisFact[]) => void): UnsubscribeFn;
+    /**
+     * Check constraints against the current state with new facts
+     */
+    private checkConstraints;
+    /**
+     * Trigger rules when new facts are added
+     *
+     * This method is called after facts are stored. It can be extended
+     * for derived fact computation where rules generate new facts based
+     * on existing facts. Currently implemented as a hook point for future
+     * enhancements.
+     *
+     * @param _newFacts The newly stored facts (unused in current implementation)
+     */
+    private triggerRules;
+    /**
+     * Trigger rules when events are appended
+     */
+    private triggerRulesForEvents;
+    /**
+     * Update the context
+     */
+    updateContext(context: TContext): void;
+    /**
+     * Get the current context
+     */
+    getContext(): TContext;
+    /**
+     * Dispose of all subscriptions
+     */
+    dispose(): void;
+}
+/**
+ * Create a new PraxisDBStore
+ *
+ * @param db The PraxisDB instance to use
+ * @param registry The PraxisRegistry for rules and constraints
+ * @param initialContext Optional initial context
+ * @param onRuleError Optional error handler for rule execution errors
+ * @returns PraxisDBStore instance
+ *
+ * @example
+ * ```typescript
+ * const db = createInMemoryDB();
+ * const registry = new PraxisRegistry();
+ * const store = createPraxisDBStore(db, registry);
+ *
+ * await store.storeFact({ tag: "UserLoggedIn", payload: { userId: "alice" } });
+ * await store.appendEvent({ tag: "LOGIN", payload: { username: "alice" } });
+ * ```
+ */
+export declare function createPraxisDBStore<TContext = unknown>(db: PraxisDB, registry: PraxisRegistry<TContext>, initialContext?: TContext, onRuleError?: RuleErrorHandler): PraxisDBStore<TContext>;
+//# sourceMappingURL=store.d.ts.map

package/dist/src/core/pluresdb/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/core/pluresdb/store.ts"],"names":[],"mappings":"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"}

package/dist/src/core/pluresdb/store.js

@@ -0,0 +1,344 @@
+/**
+ * PraxisDB Store
+ *
+ * Connects Praxis Facts, Events, Rules, and Constraints to PluresDB.
+ * Provides CRDT-backed storage for facts and append-only event streams.
+ */
+/**
+ * Key paths for Praxis data in PluresDB
+ */
+export const PRAXIS_PATHS = {
+    /** Base path for all Praxis data */
+    BASE: "/_praxis",
+    /** Path for facts storage */
+    FACTS: "/_praxis/facts",
+    /** Path for events storage */
+    EVENTS: "/_praxis/events",
+    /** Path for schema registry */
+    SCHEMAS: "/_praxis/schemas",
+};
+/**
+ * Generate a fact key path
+ * @param factTag The fact type tag
+ * @param id Optional unique identifier for the fact instance
+ */
+export function getFactPath(factTag, id) {
+    if (id) {
+        return `${PRAXIS_PATHS.FACTS}/${factTag}/${id}`;
+    }
+    return `${PRAXIS_PATHS.FACTS}/${factTag}`;
+}
+/**
+ * Generate an event stream key path
+ * @param eventTag The event type tag
+ */
+export function getEventPath(eventTag) {
+    return `${PRAXIS_PATHS.EVENTS}/${eventTag}`;
+}
+/**
+ * Generate a unique ID for facts or events
+ * Uses timestamp and random string for uniqueness
+ */
+export function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+ * Default error handler that logs to console
+ */
+const defaultErrorHandler = (ruleId, error) => {
+    // Default behavior: silent in production, can be overridden
+    if (typeof process !== "undefined" && process.env?.NODE_ENV === "development") {
+        console.error(`Error executing rule "${ruleId}":`, error);
+    }
+};
+export class PraxisDBStore {
+    db;
+    registry;
+    context;
+    subscriptions = [];
+    factWatchers = new Map();
+    onRuleError;
+    constructor(options) {
+        this.db = options.db;
+        this.registry = options.registry;
+        this.context = options.initialContext ?? {};
+        this.onRuleError = options.onRuleError ?? defaultErrorHandler;
+    }
+    /**
+     * Store a fact in PluresDB
+     *
+     * Facts are stored under `/_praxis/facts/<factTag>/<id>`
+     * If no id is provided in the payload, a timestamp-based id is used.
+     *
+     * @param fact The fact to store
+     * @returns Promise that resolves when the fact is stored
+     */
+    async storeFact(fact) {
+        // Run constraints before storing
+        const constraintResult = await this.checkConstraints([fact]);
+        if (!constraintResult.valid) {
+            throw new Error(`Constraint violation: ${constraintResult.errors.join(", ")}`);
+        }
+        await this.persistFact(fact);
+        // Trigger rule evaluation - facts stored directly may trigger derived computations
+        await this.triggerRules([fact]);
+    }
+    /**
+     * Store multiple facts in PluresDB
+     *
+     * @param facts The facts to store
+     */
+    async storeFacts(facts) {
+        // Run constraints before storing
+        const constraintResult = await this.checkConstraints(facts);
+        if (!constraintResult.valid) {
+            throw new Error(`Constraint violation: ${constraintResult.errors.join(", ")}`);
+        }
+        for (const fact of facts) {
+            await this.persistFact(fact);
+        }
+        // Trigger rule evaluation
+        await this.triggerRules(facts);
+    }
+    /**
+     * Internal method to persist a fact without constraint checking
+     * Used by both storeFact and derived fact storage
+     */
+    async persistFact(fact) {
+        const payload = fact.payload;
+        const id = payload?.id ?? generateId();
+        const path = getFactPath(fact.tag, id);
+        await this.db.set(path, fact);
+    }
+    /**
+     * Get a fact by tag and id
+     *
+     * @param factTag The fact type tag
+     * @param id The fact id
+     * @returns The fact or undefined if not found
+     */
+    async getFact(factTag, id) {
+        const path = getFactPath(factTag, id);
+        return this.db.get(path);
+    }
+    /**
+     * Append an event to the event stream
+     *
+     * Events are stored as append-only streams under `/_praxis/events/<eventTag>`
+     *
+     * @param event The event to append
+     */
+    async appendEvent(event) {
+        const path = getEventPath(event.tag);
+        // Get existing events for this tag
+        const existingEvents = await this.db.get(path) ?? [];
+        // Create new entry
+        const entry = {
+            event,
+            timestamp: Date.now(),
+            sequence: existingEvents.length,
+        };
+        // Append and store
+        const newEvents = [...existingEvents, entry];
+        await this.db.set(path, newEvents);
+        // Trigger rules with this event
+        await this.triggerRulesForEvents([event]);
+    }
+    /**
+     * Append multiple events to their respective streams
+     *
+     * @param events The events to append
+     */
+    async appendEvents(events) {
+        // Group events by tag for efficient storage
+        const eventsByTag = new Map();
+        for (const event of events) {
+            const existing = eventsByTag.get(event.tag) ?? [];
+            eventsByTag.set(event.tag, [...existing, event]);
+        }
+        // Append each group
+        for (const [tag, tagEvents] of eventsByTag) {
+            const path = getEventPath(tag);
+            const existingEvents = await this.db.get(path) ?? [];
+            let sequence = existingEvents.length;
+            const newEntries = tagEvents.map(event => ({
+                event,
+                timestamp: Date.now(),
+                sequence: sequence++,
+            }));
+            await this.db.set(path, [...existingEvents, ...newEntries]);
+        }
+        // Trigger rules
+        await this.triggerRulesForEvents(events);
+    }
+    /**
+     * Get events from a stream
+     *
+     * @param eventTag The event type tag
+     * @param options Query options
+     * @returns Array of event stream entries
+     */
+    async getEvents(eventTag, options) {
+        const path = getEventPath(eventTag);
+        const events = await this.db.get(path) ?? [];
+        let result = events;
+        if (options?.since !== undefined) {
+            const sinceTimestamp = options.since;
+            result = result.filter(e => e.timestamp > sinceTimestamp);
+        }
+        if (options?.limit !== undefined) {
+            result = result.slice(-options.limit);
+        }
+        return result;
+    }
+    /**
+     * Watch a fact path for changes
+     *
+     * @param factTag The fact type tag to watch
+     * @param callback Called when facts of this type change
+     * @returns Unsubscribe function
+     */
+    watchFacts(factTag, callback) {
+        const path = getFactPath(factTag);
+        // Register the callback
+        if (!this.factWatchers.has(factTag)) {
+            this.factWatchers.set(factTag, new Set());
+        }
+        const watchers = this.factWatchers.get(factTag);
+        if (watchers) {
+            watchers.add(callback);
+        }
+        // Watch the path in the DB
+        const unsubscribe = this.db.watch(path, (fact) => {
+            callback([fact]);
+        });
+        this.subscriptions.push(unsubscribe);
+        return () => {
+            unsubscribe();
+            this.factWatchers.get(factTag)?.delete(callback);
+        };
+    }
+    /**
+     * Check constraints against the current state with new facts
+     */
+    async checkConstraints(newFacts) {
+        const constraints = this.registry.getAllConstraints();
+        const errors = [];
+        // Build a minimal state for constraint checking
+        const state = {
+            context: this.context,
+            facts: newFacts,
+            meta: {},
+        };
+        for (const constraint of constraints) {
+            try {
+                const result = constraint.impl(state);
+                if (result === false) {
+                    errors.push(`Constraint "${constraint.id}" violated`);
+                }
+                else if (typeof result === "string") {
+                    errors.push(result);
+                }
+            }
+            catch (error) {
+                errors.push(`Error checking constraint "${constraint.id}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Trigger rules when new facts are added
+     *
+     * This method is called after facts are stored. It can be extended
+     * for derived fact computation where rules generate new facts based
+     * on existing facts. Currently implemented as a hook point for future
+     * enhancements.
+     *
+     * @param _newFacts The newly stored facts (unused in current implementation)
+     */
+    async triggerRules(_newFacts) {
+        // Rules are typically triggered by events, not facts
+        // This method serves as a hook for derived fact computation
+        // which can be implemented by subclasses or future enhancements
+    }
+    /**
+     * Trigger rules when events are appended
+     */
+    async triggerRulesForEvents(events) {
+        const rules = this.registry.getAllRules();
+        // Build state for rule evaluation
+        const state = {
+            context: this.context,
+            facts: [],
+            meta: {},
+        };
+        // Execute each rule
+        const derivedFacts = [];
+        for (const rule of rules) {
+            try {
+                const facts = rule.impl(state, events);
+                derivedFacts.push(...facts);
+            }
+            catch (error) {
+                this.onRuleError(rule.id, error);
+            }
+        }
+        // Store derived facts (without re-triggering rules to avoid infinite loops)
+        if (derivedFacts.length > 0) {
+            const constraintResult = await this.checkConstraints(derivedFacts);
+            if (constraintResult.valid) {
+                for (const fact of derivedFacts) {
+                    await this.persistFact(fact);
+                }
+            }
+        }
+    }
+    /**
+     * Update the context
+     */
+    updateContext(context) {
+        this.context = context;
+    }
+    /**
+     * Get the current context
+     */
+    getContext() {
+        return this.context;
+    }
+    /**
+     * Dispose of all subscriptions
+     */
+    dispose() {
+        for (const unsubscribe of this.subscriptions) {
+            unsubscribe();
+        }
+        this.subscriptions = [];
+        this.factWatchers.clear();
+    }
+}
+/**
+ * Create a new PraxisDBStore
+ *
+ * @param db The PraxisDB instance to use
+ * @param registry The PraxisRegistry for rules and constraints
+ * @param initialContext Optional initial context
+ * @param onRuleError Optional error handler for rule execution errors
+ * @returns PraxisDBStore instance
+ *
+ * @example
+ * ```typescript
+ * const db = createInMemoryDB();
+ * const registry = new PraxisRegistry();
+ * const store = createPraxisDBStore(db, registry);
+ *
+ * await store.storeFact({ tag: "UserLoggedIn", payload: { userId: "alice" } });
+ * await store.appendEvent({ tag: "LOGIN", payload: { username: "alice" } });
+ * ```
+ */
+export function createPraxisDBStore(db, registry, initialContext, onRuleError) {
+    return new PraxisDBStore({ db, registry, initialContext, onRuleError });
+}
+//# sourceMappingURL=store.js.map