@smithers-orchestrator/memory 0.16.0

package/src/namespaceToString.js

@@ -0,0 +1,9 @@
+
+/** @typedef {import("./MemoryNamespace.ts").MemoryNamespace} MemoryNamespace */
+/**
+ * @param {MemoryNamespace} ns
+ * @returns {string}
+ */
+export function namespaceToString(ns) {
+    return `${ns.kind}:${ns.id}`;
+}

package/src/parseNamespace.js

@@ -0,0 +1,18 @@
+
+/** @typedef {import("./MemoryNamespace.ts").MemoryNamespace} MemoryNamespace */
+/**
+ * @param {string} str
+ * @returns {MemoryNamespace}
+ */
+export function parseNamespace(str) {
+    const idx = str.indexOf(":");
+    if (idx < 0) {
+        return { kind: "global", id: str };
+    }
+    const kind = str.slice(0, idx);
+    const id = str.slice(idx + 1);
+    if (!["workflow", "agent", "user", "global"].includes(kind)) {
+        return { kind: "global", id: str };
+    }
+    return { kind, id };
+}

package/src/processors.js

@@ -0,0 +1,7 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./MemoryProcessor.ts").MemoryProcessor} MemoryProcessor */
+// @smithers-type-exports-end
+
+export { TtlGarbageCollector } from "./TtlGarbageCollector.js";
+export { TokenLimiter } from "./TokenLimiter.js";
+export { Summarizer } from "./Summarizer.js";

package/src/react-types.ts

@@ -0,0 +1 @@
+export type { TaskMemoryConfig } from "@smithers-orchestrator/graph/types";

package/src/schema.js

@@ -0,0 +1,38 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+// ---------------------------------------------------------------------------
+// Memory Facts -- (namespace, key) primary key
+// ---------------------------------------------------------------------------
+export const smithersMemoryFacts = sqliteTable("_smithers_memory_facts", {
+    namespace: text("namespace").notNull(),
+    key: text("key").notNull(),
+    valueJson: text("value_json").notNull(),
+    schemaSig: text("schema_sig"),
+    createdAtMs: integer("created_at_ms").notNull(),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+    ttlMs: integer("ttl_ms"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.namespace, t.key] }),
+}));
+// ---------------------------------------------------------------------------
+// Memory Threads
+// ---------------------------------------------------------------------------
+export const smithersMemoryThreads = sqliteTable("_smithers_memory_threads", {
+    threadId: text("thread_id").primaryKey(),
+    namespace: text("namespace").notNull(),
+    title: text("title"),
+    metadataJson: text("metadata_json"),
+    createdAtMs: integer("created_at_ms").notNull(),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+});
+// ---------------------------------------------------------------------------
+// Memory Messages
+// ---------------------------------------------------------------------------
+export const smithersMemoryMessages = sqliteTable("_smithers_memory_messages", {
+    id: text("id").primaryKey(),
+    threadId: text("thread_id").notNull(),
+    role: text("role").notNull(),
+    contentJson: text("content_json").notNull(),
+    runId: text("run_id"),
+    nodeId: text("node_id"),
+    createdAtMs: integer("created_at_ms").notNull(),
+});

package/src/service.js

@@ -0,0 +1,7 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./MemoryLayerConfig.ts").MemoryLayerConfig} MemoryLayerConfig */
+/** @typedef {import("./MemoryServiceApi.ts").MemoryServiceApi} MemoryServiceApi */
+// @smithers-type-exports-end
+
+export { MemoryService } from "./MemoryService.js";
+export { createMemoryLayer } from "./createMemoryLayer.js";

package/src/store/MemoryStore.js

@@ -0,0 +1,5 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./MemoryStore.ts").MemoryStore} MemoryStore */
+// @smithers-type-exports-end
+
+import { Effect } from "effect";

package/src/store/MemoryStore.ts

@@ -0,0 +1,68 @@
+import type { Effect } from "effect";
+import type { SmithersError } from "@smithers-orchestrator/errors";
+import type { MemoryNamespace } from "../MemoryNamespace";
+import type { MemoryFact } from "../MemoryFact";
+import type { MemoryThread } from "../MemoryThread";
+import type { MemoryMessage } from "../MemoryMessage";
+
+export type MemoryStore = {
+  getFact: (
+    ns: MemoryNamespace,
+    key: string,
+  ) => Promise<MemoryFact | undefined>;
+  setFact: (
+    ns: MemoryNamespace,
+    key: string,
+    value: unknown,
+    ttlMs?: number,
+  ) => Promise<void>;
+  deleteFact: (ns: MemoryNamespace, key: string) => Promise<void>;
+  listFacts: (ns: MemoryNamespace) => Promise<MemoryFact[]>;
+  createThread: (ns: MemoryNamespace, title?: string) => Promise<MemoryThread>;
+  getThread: (threadId: string) => Promise<MemoryThread | undefined>;
+  deleteThread: (threadId: string) => Promise<void>;
+  saveMessage: (
+    msg: Omit<MemoryMessage, "createdAtMs"> & { createdAtMs?: number },
+  ) => Promise<void>;
+  listMessages: (threadId: string, limit?: number) => Promise<MemoryMessage[]>;
+  countMessages: (threadId: string) => Promise<number>;
+  deleteExpiredFacts: () => Promise<number>;
+  getFactEffect: (
+    ns: MemoryNamespace,
+    key: string,
+  ) => Effect.Effect<MemoryFact | undefined, SmithersError>;
+  setFactEffect: (
+    ns: MemoryNamespace,
+    key: string,
+    value: unknown,
+    ttlMs?: number,
+  ) => Effect.Effect<void, SmithersError>;
+  deleteFactEffect: (
+    ns: MemoryNamespace,
+    key: string,
+  ) => Effect.Effect<void, SmithersError>;
+  listFactsEffect: (
+    ns: MemoryNamespace,
+  ) => Effect.Effect<MemoryFact[], SmithersError>;
+  createThreadEffect: (
+    ns: MemoryNamespace,
+    title?: string,
+  ) => Effect.Effect<MemoryThread, SmithersError>;
+  getThreadEffect: (
+    threadId: string,
+  ) => Effect.Effect<MemoryThread | undefined, SmithersError>;
+  deleteThreadEffect: (
+    threadId: string,
+  ) => Effect.Effect<void, SmithersError>;
+  saveMessageEffect: (
+    msg: Omit<MemoryMessage, "createdAtMs"> & { createdAtMs?: number },
+  ) => Effect.Effect<void, SmithersError>;
+  listMessagesEffect: (
+    threadId: string,
+    limit?: number,
+  ) => Effect.Effect<MemoryMessage[], SmithersError>;
+  countMessagesEffect: (
+    threadId: string,
+  ) => Effect.Effect<number, SmithersError>;
+  deleteExpiredFactsEffect: () => Effect.Effect<number, SmithersError>;
+};

package/src/store/MemoryStoreDb.js

@@ -0,0 +1,6 @@
+import { Context } from "effect";
+/** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase<any>} BunSQLiteDatabaseAny */
+
+/** @type {Context.Tag<BunSQLiteDatabaseAny, BunSQLiteDatabaseAny>} */
+export const MemoryStoreDb =
+  Context.GenericTag("MemoryStoreDb");

package/src/store/MemoryStoreLive.js

@@ -0,0 +1,306 @@
+import { and, desc, eq, sql } from "drizzle-orm";
+import { Effect, Layer, Metric } from "effect";
+import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { dbQueryDuration } from "@smithers-orchestrator/observability/metrics";
+import { nowMs } from "@smithers-orchestrator/scheduler/nowMs";
+import { namespaceToString } from "../namespaceToString.js";
+import { smithersMemoryFacts, smithersMemoryThreads, smithersMemoryMessages, } from "../schema.js";
+import { memoryFactReads } from "../memoryFactReads.js";
+import { memoryFactWrites } from "../memoryFactWrites.js";
+import { memoryMessageSaves } from "../memoryMessageSaves.js";
+import { MemoryStoreDb } from "./MemoryStoreDb.js";
+import { MemoryStoreService } from "./MemoryStoreService.js";
+/** @typedef {import("./MemoryStore.ts").MemoryStore} MemoryStore */
+/** @typedef {import("../MemoryNamespace.ts").MemoryNamespace} MemoryNamespace */
+/** @typedef {import("../MemoryFact.ts").MemoryFact} MemoryFact */
+/** @typedef {import("../MemoryMessage.ts").MemoryMessage} MemoryMessage */
+/** @typedef {import("../MemoryThread.ts").MemoryThread} MemoryThread */
+/** @typedef {import("@smithers-orchestrator/errors/SmithersError").SmithersError} SmithersError */
+
+/** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * @template A
+ * @param {string} label
+ * @param {() => PromiseLike<A>} operation
+ * @returns {Effect.Effect<A, SmithersError>}
+ */
+function readEffect(label, operation) {
+    return Effect.gen(function* () {
+        const start = performance.now();
+        const result = yield* Effect.tryPromise({
+            try: () => operation(),
+            catch: (cause) => toSmithersError(cause, label, {
+                code: "DB_QUERY_FAILED",
+                details: { operation: label },
+            }),
+        });
+        yield* Metric.update(dbQueryDuration, performance.now() - start);
+        return result;
+    }).pipe(Effect.annotateLogs({ dbOperation: label }), Effect.withLogSpan(`memory:${label}`));
+}
+/**
+ * @template A
+ * @param {string} label
+ * @param {() => PromiseLike<A>} operation
+ * @returns {Effect.Effect<A, SmithersError>}
+ */
+function writeEffect(label, operation) {
+    return Effect.gen(function* () {
+        const start = performance.now();
+        const result = yield* Effect.tryPromise({
+            try: () => operation(),
+            catch: (cause) => toSmithersError(cause, label, {
+                code: "DB_WRITE_FAILED",
+                details: { operation: label },
+            }),
+        });
+        yield* Metric.update(dbQueryDuration, performance.now() - start);
+        return result;
+    }).pipe(Effect.annotateLogs({ dbOperation: label }), Effect.withLogSpan(`memory:${label}`));
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * @param {BunSQLiteDatabase<any>} db
+ * @returns {MemoryStore}
+ */
+function makeMemoryStore(db) {
+    // --- Working Memory Effects ---
+    /**
+   * @param {MemoryNamespace} ns
+   * @param {string} key
+   * @returns {Effect.Effect<MemoryFact | undefined, SmithersError>}
+   */
+    function getFactEffect(ns, key) {
+        const nsStr = namespaceToString(ns);
+        return Effect.gen(function* () {
+            yield* Metric.increment(memoryFactReads);
+            const rows = yield* readEffect("memory getFact", () => db
+                .select()
+                .from(smithersMemoryFacts)
+                .where(and(eq(smithersMemoryFacts.namespace, nsStr), eq(smithersMemoryFacts.key, key)))
+                .limit(1));
+            const row = rows[0];
+            if (!row)
+                return undefined;
+            return {
+                namespace: row.namespace,
+                key: row.key,
+                valueJson: row.valueJson,
+                schemaSig: row.schemaSig,
+                createdAtMs: row.createdAtMs,
+                updatedAtMs: row.updatedAtMs,
+                ttlMs: row.ttlMs,
+            };
+        });
+    }
+    /**
+   * @param {MemoryNamespace} ns
+   * @param {string} key
+   * @param {unknown} value
+   * @param {number} [ttlMs]
+   * @returns {Effect.Effect<void, SmithersError>}
+   */
+    function setFactEffect(ns, key, value, ttlMs) {
+        const nsStr = namespaceToString(ns);
+        const now = nowMs();
+        return Effect.gen(function* () {
+            yield* Metric.increment(memoryFactWrites);
+            yield* writeEffect("memory setFact", () => db
+                .insert(smithersMemoryFacts)
+                .values({
+                namespace: nsStr,
+                key,
+                valueJson: JSON.stringify(value),
+                createdAtMs: now,
+                updatedAtMs: now,
+                ttlMs: ttlMs ?? null,
+            })
+                .onConflictDoUpdate({
+                target: [smithersMemoryFacts.namespace, smithersMemoryFacts.key],
+                set: {
+                    valueJson: JSON.stringify(value),
+                    updatedAtMs: now,
+                    ttlMs: ttlMs ?? null,
+                },
+            }));
+        });
+    }
+    /**
+   * @param {MemoryNamespace} ns
+   * @param {string} key
+   * @returns {Effect.Effect<void, SmithersError>}
+   */
+    function deleteFactEffect(ns, key) {
+        const nsStr = namespaceToString(ns);
+        return writeEffect("memory deleteFact", () => db
+            .delete(smithersMemoryFacts)
+            .where(and(eq(smithersMemoryFacts.namespace, nsStr), eq(smithersMemoryFacts.key, key)))).pipe(Effect.asVoid);
+    }
+    /**
+   * @param {MemoryNamespace} ns
+   * @returns {Effect.Effect<MemoryFact[], SmithersError>}
+   */
+    function listFactsEffect(ns) {
+        const nsStr = namespaceToString(ns);
+        return readEffect("memory listFacts", () => db
+            .select()
+            .from(smithersMemoryFacts)
+            .where(eq(smithersMemoryFacts.namespace, nsStr))
+            .orderBy(smithersMemoryFacts.key)).pipe(Effect.map((rows) => rows.map((row) => ({
+            namespace: row.namespace,
+            key: row.key,
+            valueJson: row.valueJson,
+            schemaSig: row.schemaSig,
+            createdAtMs: row.createdAtMs,
+            updatedAtMs: row.updatedAtMs,
+            ttlMs: row.ttlMs,
+        }))));
+    }
+    // --- Thread Effects ---
+    /**
+   * @param {MemoryNamespace} ns
+   * @param {string} [title]
+   * @returns {Effect.Effect<MemoryThread, SmithersError>}
+   */
+    function createThreadEffect(ns, title) {
+        const nsStr = namespaceToString(ns);
+        const now = nowMs();
+        const threadId = crypto.randomUUID();
+        const thread = {
+            threadId,
+            namespace: nsStr,
+            title: title ?? null,
+            metadataJson: null,
+            createdAtMs: now,
+            updatedAtMs: now,
+        };
+        return writeEffect("memory createThread", () => db.insert(smithersMemoryThreads).values(thread)).pipe(Effect.map(() => thread));
+    }
+    /**
+   * @param {string} threadId
+   * @returns {Effect.Effect<MemoryThread | undefined, SmithersError>}
+   */
+    function getThreadEffect(threadId) {
+        return readEffect("memory getThread", () => db
+            .select()
+            .from(smithersMemoryThreads)
+            .where(eq(smithersMemoryThreads.threadId, threadId))
+            .limit(1)).pipe(Effect.map((rows) => rows[0]));
+    }
+    /**
+   * @param {string} threadId
+   * @returns {Effect.Effect<void, SmithersError>}
+   */
+    function deleteThreadEffect(threadId) {
+        return Effect.gen(function* () {
+            // Delete messages first
+            yield* writeEffect("memory deleteThreadMessages", () => db
+                .delete(smithersMemoryMessages)
+                .where(eq(smithersMemoryMessages.threadId, threadId)));
+            // Delete the thread
+            yield* writeEffect("memory deleteThread", () => db
+                .delete(smithersMemoryThreads)
+                .where(eq(smithersMemoryThreads.threadId, threadId)));
+        });
+    }
+    // --- Message Effects ---
+    /**
+   * @param {Omit<MemoryMessage, "createdAtMs"> & { createdAtMs?: number }} msg
+   * @returns {Effect.Effect<void, SmithersError>}
+   */
+    function saveMessageEffect(msg) {
+        return Effect.gen(function* () {
+            yield* Metric.increment(memoryMessageSaves);
+            yield* writeEffect("memory saveMessage", () => db.insert(smithersMemoryMessages).values({
+                id: msg.id,
+                threadId: msg.threadId,
+                role: msg.role,
+                contentJson: msg.contentJson,
+                runId: msg.runId ?? null,
+                nodeId: msg.nodeId ?? null,
+                createdAtMs: msg.createdAtMs ?? nowMs(),
+            }));
+        });
+    }
+    /**
+   * @param {string} threadId
+   * @param {number} [limit]
+   * @returns {Effect.Effect<MemoryMessage[], SmithersError>}
+   */
+    function listMessagesEffect(threadId, limit) {
+        return readEffect("memory listMessages", () => {
+            let query = db
+                .select()
+                .from(smithersMemoryMessages)
+                .where(eq(smithersMemoryMessages.threadId, threadId))
+                .orderBy(smithersMemoryMessages.createdAtMs);
+            if (limit) {
+                query = query.limit(limit);
+            }
+            return query;
+        }).pipe(Effect.map((rows) => rows.map((row) => ({
+            id: row.id,
+            threadId: row.threadId,
+            role: row.role,
+            contentJson: row.contentJson,
+            runId: row.runId,
+            nodeId: row.nodeId,
+            createdAtMs: row.createdAtMs,
+        }))));
+    }
+    /**
+   * @param {string} threadId
+   * @returns {Effect.Effect<number, SmithersError>}
+   */
+    function countMessagesEffect(threadId) {
+        return readEffect("memory countMessages", () => db
+            .select({ count: sql `count(*)` })
+            .from(smithersMemoryMessages)
+            .where(eq(smithersMemoryMessages.threadId, threadId))).pipe(Effect.map((rows) => rows[0]?.count ?? 0));
+    }
+    // --- Maintenance ---
+    /**
+   * @returns {Effect.Effect<number, SmithersError>}
+   */
+    function deleteExpiredFactsEffect() {
+        const now = nowMs();
+        return writeEffect("memory deleteExpiredFacts", () => db
+            .delete(smithersMemoryFacts)
+            .where(and(sql `${smithersMemoryFacts.ttlMs} IS NOT NULL`, sql `${smithersMemoryFacts.updatedAtMs} + ${smithersMemoryFacts.ttlMs} < ${now}`))).pipe(Effect.map((result) => result?.changes ?? result?.rowsAffected ?? 0));
+    }
+    // --- Build the store ---
+    return {
+        // Promise variants (delegate to Effect)
+        getFact: (ns, key) => Effect.runPromise(getFactEffect(ns, key)),
+        setFact: (ns, key, value, ttlMs) => Effect.runPromise(setFactEffect(ns, key, value, ttlMs)),
+        deleteFact: (ns, key) => Effect.runPromise(deleteFactEffect(ns, key)),
+        listFacts: (ns) => Effect.runPromise(listFactsEffect(ns)),
+        createThread: (ns, title) => Effect.runPromise(createThreadEffect(ns, title)),
+        getThread: (threadId) => Effect.runPromise(getThreadEffect(threadId)),
+        deleteThread: (threadId) => Effect.runPromise(deleteThreadEffect(threadId)),
+        saveMessage: (msg) => Effect.runPromise(saveMessageEffect(msg)),
+        listMessages: (threadId, limit) => Effect.runPromise(listMessagesEffect(threadId, limit)),
+        countMessages: (threadId) => Effect.runPromise(countMessagesEffect(threadId)),
+        deleteExpiredFacts: () => Effect.runPromise(deleteExpiredFactsEffect()),
+        // Effect variants
+        getFactEffect,
+        setFactEffect,
+        deleteFactEffect,
+        listFactsEffect,
+        createThreadEffect,
+        getThreadEffect,
+        deleteThreadEffect,
+        saveMessageEffect,
+        listMessagesEffect,
+        countMessagesEffect,
+        deleteExpiredFactsEffect,
+    };
+}
+/** @type {Layer.Layer<MemoryStoreService, never, BunSQLiteDatabase<any>>} */
+export const MemoryStoreLive = Layer.effect(MemoryStoreService, Effect.map(MemoryStoreDb, (db) => makeMemoryStore(db)));

package/src/store/MemoryStoreService.js

@@ -0,0 +1,10 @@
+import { Context } from "effect";
+/** @typedef {import("./MemoryStore.ts").MemoryStore} MemoryStore */
+
+const MemoryStoreServiceBase =
+  /** @type {Context.TagClass<MemoryStoreService, "MemoryStoreService", MemoryStore>} */ (
+    /** @type {unknown} */ (Context.Tag("MemoryStoreService")())
+  );
+
+export class MemoryStoreService extends MemoryStoreServiceBase {
+}

package/src/store/createMemoryStore.js

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { MemoryStoreService } from "./MemoryStoreService.js";
+import { createMemoryStoreLayer } from "./createMemoryStoreLayer.js";
+/** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
+/** @typedef {import("./MemoryStore.ts").MemoryStore} MemoryStore */
+
+/**
+ * @param {BunSQLiteDatabase<any>} db
+ * @returns {MemoryStore}
+ */
+export function createMemoryStore(db) {
+    return Effect.runSync(MemoryStoreService.pipe(Effect.provide(createMemoryStoreLayer(db))));
+}

package/src/store/createMemoryStoreLayer.js

@@ -0,0 +1,13 @@
+import { Layer } from "effect";
+import { MemoryStoreDb } from "./MemoryStoreDb.js";
+import { MemoryStoreLive } from "./MemoryStoreLive.js";
+import { MemoryStoreService } from "./MemoryStoreService.js";
+/** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase} BunSQLiteDatabase */
+
+/**
+ * @param {BunSQLiteDatabase<any>} db
+ * @returns {Layer.Layer<MemoryStoreService, never, never>}
+ */
+export function createMemoryStoreLayer(db) {
+    return MemoryStoreLive.pipe(Layer.provide(Layer.succeed(MemoryStoreDb, db)));
+}

package/src/store/index.js

@@ -0,0 +1,9 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./MemoryStore.ts").MemoryStore} MemoryStore */
+// @smithers-type-exports-end
+
+export { MemoryStoreDb } from "./MemoryStoreDb.js";
+export { MemoryStoreService } from "./MemoryStoreService.js";
+export { MemoryStoreLive } from "./MemoryStoreLive.js";
+export { createMemoryStoreLayer } from "./createMemoryStoreLayer.js";
+export { createMemoryStore } from "./createMemoryStore.js";

package/src/types.js

@@ -0,0 +1,21 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./MemoryFact.ts").MemoryFact} MemoryFact */
+/** @typedef {import("./MemoryLayerConfig.ts").MemoryLayerConfig} MemoryLayerConfig */
+/** @typedef {import("./MemoryMessage.ts").MemoryMessage} MemoryMessage */
+/** @typedef {import("./MemoryNamespace.ts").MemoryNamespace} MemoryNamespace */
+/** @typedef {import("./MemoryNamespaceKind.ts").MemoryNamespaceKind} MemoryNamespaceKind */
+/** @typedef {import("./MemoryProcessor.ts").MemoryProcessor} MemoryProcessor */
+/** @typedef {import("./MemoryProcessorConfig.ts").MemoryProcessorConfig} MemoryProcessorConfig */
+/** @typedef {import("./MemoryServiceApi.ts").MemoryServiceApi} MemoryServiceApi */
+/** @typedef {import("./MemoryThread.ts").MemoryThread} MemoryThread */
+/** @typedef {import("./MessageHistoryConfig.ts").MessageHistoryConfig} MessageHistoryConfig */
+/** @typedef {import("./SemanticRecallConfig.ts").SemanticRecallConfig} SemanticRecallConfig */
+/** @typedef {import("./TaskMemoryConfig.ts").TaskMemoryConfig} TaskMemoryConfig */
+/**
+ * @template {import("zod").z.ZodObject<any>} [T=import("zod").z.ZodObject<any>]
+ * @typedef {import("./WorkingMemoryConfig.ts").WorkingMemoryConfig<T>} WorkingMemoryConfig
+ */
+// @smithers-type-exports-end
+
+export { namespaceToString } from "./namespaceToString.js";
+export { parseNamespace } from "./parseNamespace.js";