dotmem 0.0.9 → 0.1.0

package/cli.cjs

@@ -39,6 +39,18 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// suppress-idb-warning.ts
+var orig;
+var init_suppress_idb_warning = __esm({
+  "suppress-idb-warning.ts"() {
+    orig = console.warn.bind(console);
+    console.warn = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("IndexedDB is not available")) return;
+      orig(...args);
+    };
+  }
+});
+
 // core/env.ts
 var DEV;
 var init_env = __esm({
@@ -73,6 +85,7 @@ function configure(opts) {
 var g, STORE_PREFIX, INDEX_KEY, journal, journal_default;
 var init_journal = __esm({
   "core/memory/journal.ts"() {
+    init_suppress_idb_warning();
     init_env();
     g = globalThis;
     __name(namespace, "namespace");
@@ -5272,7 +5285,7 @@ function encodeMemFile(stateValue, preserved) {
 function decodeMemDocument(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid .mem file format");
   const file = value;
-  if (file.format !== MEM_FORMAT) throw new Error("Invalid .mem file format");
+  if (file.format !== MEM_FORMAT && file.format !== MEM_FORMAT_LEGACY) throw new Error("Invalid .mem file format");
   if (file.version === MEM_FORMAT_VERSION_V1) {
     if (!file.knowledge) throw new Error("Invalid .mem file format");
     return { state: validateSourceState(file.knowledge) };
@@ -5354,11 +5367,12 @@ function decodeMemDocument(value) {
     preserved: { map: structuredClone(map), data: structuredClone(stateRecord) }
   };
 }
-var MEM_FORMAT, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
+var MEM_FORMAT, MEM_FORMAT_LEGACY, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
 var init_mem_codec = __esm({
   "core/knowledge/mem-codec.ts"() {
     init_state();
     MEM_FORMAT = "dotmem.knowledge";
+    MEM_FORMAT_LEGACY = "memorio.knowledge";
     MEM_FORMAT_VERSION = 2;
     MEM_FORMAT_VERSION_V1 = 1;
     expectedFields = {
@@ -5507,12 +5521,13 @@ async function inspectMem(input) {
     return { status: artifactError.code, representation: "unknown", message: artifactError.message, parts: [] };
   }
 }
-var MEM_PACKAGE_FORMAT, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
+var MEM_PACKAGE_FORMAT, MEM_PACKAGE_FORMAT_LEGACY, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
 var init_mem_package = __esm({
   "core/knowledge/mem-package.ts"() {
     init_browser();
     init_mem_codec();
     MEM_PACKAGE_FORMAT = "dotmem.package";
+    MEM_PACKAGE_FORMAT_LEGACY = "memorio.package";
     MEM_PACKAGE_VERSION = 1;
     MEM_PACKAGE_LIMITS = Object.freeze({
       maximumPackageBytes: 10 * 1024 * 1024,
@@ -5697,10 +5712,10 @@ ${contentId}
         if (!parts[path3]) throw new MemArtifactError("invalid", `Missing MEM package part: ${path3}`);
       }
       const manifest = parseJson(parts[MANIFEST_PATH], MANIFEST_PATH);
-      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format || manifest.version !== MEM_PACKAGE_VERSION) {
+      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format !== MEM_PACKAGE_FORMAT_LEGACY || manifest.version !== MEM_PACKAGE_VERSION) {
         throw new MemArtifactError("unsupported", "Unsupported MEM package format or version");
       }
-      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
+      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format !== MEM_FORMAT_LEGACY || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
         throw new MemArtifactError("invalid", "Invalid MEM package manifest");
       }
       const integrity = parseJson(parts[INTEGRITY_PATH], INTEGRITY_PATH);
@@ -9073,6 +9088,7 @@ function _inferConfidence(claim) {
 var LOGIC_MEM_FILE, nodeCwd2, cachedRuntime, LogicEngine, logic, logic_default;
 var init_logic = __esm({
   "core/logic/index.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_mem_repository();
     init_acquisition_boundary();
@@ -9466,6 +9482,7 @@ async function resetKnowledgeRuntimeCaches() {
 var EmptyLogicRepository, KNOWLEDGE_STATE_KEY, knowledgeSaveQueue, StoreKnowledgeRepository, RuntimeSlot, projectSlot, userSlot, installDotMemReadme;
 var init_knowledge_runtime = __esm({
   "core/memory/knowledge-runtime.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_project_identity();
     init_user_paths();
@@ -9998,6 +10015,7 @@ async function getEntry(key) {
 var MEMORY_INDEX_KEY, SUPERSEDED_PREFIX, entries;
 var init_entries = __esm({
   "core/memory/entries.ts"() {
+    init_suppress_idb_warning();
     init_env();
     init_journal();
     MEMORY_INDEX_KEY = "__dotmem_memory_index__";
@@ -10350,6 +10368,7 @@ async function findClaimAcrossAllSources(claimId, scope, sourceProject) {
 var acquire;
 var init_acquire = __esm({
   "core/memory/acquire.ts"() {
+    init_suppress_idb_warning();
     init_env();
     init_project_identity();
     init_project_anchor();
@@ -11948,6 +11967,7 @@ async function bootstrapProject() {
 var pendingDetectionEvents, detectionFlushScheduled, flushDetectionEvents; exports.memory = void 0;
 var init_memory = __esm({
   "core/memory/index.ts"() {
+    init_suppress_idb_warning();
     init_journal();
     init_brain();
     init_knowledge_runtime();
@@ -12854,6 +12874,7 @@ var init_policy3 = __esm({
 });
 
 // core/cli/index.ts
+init_suppress_idb_warning();
 init_memory();
 
 // core/continuity/freshness.ts
@@ -14234,7 +14255,7 @@ Run \`npx dotmem <command> --help\` for command-specific options.
 Memory:
   context "<situation>" [--explain] [--json] [--full] [--claims-only] [--limit <N>] [--format brief]
                               project acquired experience for a situation
-  init                         initialize dotmem for the current project (.mem/)
+  init                         initialize dotmem for the current project (.dotmem/)
   acquire                      acquire durable experience from a JSON claim on stdin
   learn "<text>" [--scope <user|project>] [--situation "<text>"] [--id "<id>"]
                               acquire a claim from plain text (shorthand for acquire)

package/cli.js

@@ -30,6 +30,18 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// suppress-idb-warning.ts
+var orig;
+var init_suppress_idb_warning = __esm({
+  "suppress-idb-warning.ts"() {
+    orig = console.warn.bind(console);
+    console.warn = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("IndexedDB is not available")) return;
+      orig(...args);
+    };
+  }
+});
+
 // core/env.ts
 var DEV;
 var init_env = __esm({
@@ -64,6 +76,7 @@ function configure(opts) {
 var g, STORE_PREFIX, INDEX_KEY, journal, journal_default;
 var init_journal = __esm({
   "core/memory/journal.ts"() {
+    init_suppress_idb_warning();
     init_env();
     g = globalThis;
     __name(namespace, "namespace");
@@ -5263,7 +5276,7 @@ function encodeMemFile(stateValue, preserved) {
 function decodeMemDocument(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid .mem file format");
   const file = value;
-  if (file.format !== MEM_FORMAT) throw new Error("Invalid .mem file format");
+  if (file.format !== MEM_FORMAT && file.format !== MEM_FORMAT_LEGACY) throw new Error("Invalid .mem file format");
   if (file.version === MEM_FORMAT_VERSION_V1) {
     if (!file.knowledge) throw new Error("Invalid .mem file format");
     return { state: validateSourceState(file.knowledge) };
@@ -5345,11 +5358,12 @@ function decodeMemDocument(value) {
     preserved: { map: structuredClone(map), data: structuredClone(stateRecord) }
   };
 }
-var MEM_FORMAT, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
+var MEM_FORMAT, MEM_FORMAT_LEGACY, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
 var init_mem_codec = __esm({
   "core/knowledge/mem-codec.ts"() {
     init_state();
     MEM_FORMAT = "dotmem.knowledge";
+    MEM_FORMAT_LEGACY = "memorio.knowledge";
     MEM_FORMAT_VERSION = 2;
     MEM_FORMAT_VERSION_V1 = 1;
     expectedFields = {
@@ -5498,12 +5512,13 @@ async function inspectMem(input) {
     return { status: artifactError.code, representation: "unknown", message: artifactError.message, parts: [] };
   }
 }
-var MEM_PACKAGE_FORMAT, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
+var MEM_PACKAGE_FORMAT, MEM_PACKAGE_FORMAT_LEGACY, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
 var init_mem_package = __esm({
   "core/knowledge/mem-package.ts"() {
     init_browser();
     init_mem_codec();
     MEM_PACKAGE_FORMAT = "dotmem.package";
+    MEM_PACKAGE_FORMAT_LEGACY = "memorio.package";
     MEM_PACKAGE_VERSION = 1;
     MEM_PACKAGE_LIMITS = Object.freeze({
       maximumPackageBytes: 10 * 1024 * 1024,
@@ -5688,10 +5703,10 @@ ${contentId}
         if (!parts[path3]) throw new MemArtifactError("invalid", `Missing MEM package part: ${path3}`);
       }
       const manifest = parseJson(parts[MANIFEST_PATH], MANIFEST_PATH);
-      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format || manifest.version !== MEM_PACKAGE_VERSION) {
+      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format !== MEM_PACKAGE_FORMAT_LEGACY || manifest.version !== MEM_PACKAGE_VERSION) {
         throw new MemArtifactError("unsupported", "Unsupported MEM package format or version");
       }
-      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
+      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format !== MEM_FORMAT_LEGACY || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
         throw new MemArtifactError("invalid", "Invalid MEM package manifest");
       }
       const integrity = parseJson(parts[INTEGRITY_PATH], INTEGRITY_PATH);
@@ -9064,6 +9079,7 @@ function _inferConfidence(claim) {
 var LOGIC_MEM_FILE, nodeCwd2, cachedRuntime, LogicEngine, logic, logic_default;
 var init_logic = __esm({
   "core/logic/index.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_mem_repository();
     init_acquisition_boundary();
@@ -9457,6 +9473,7 @@ async function resetKnowledgeRuntimeCaches() {
 var EmptyLogicRepository, KNOWLEDGE_STATE_KEY, knowledgeSaveQueue, StoreKnowledgeRepository, RuntimeSlot, projectSlot, userSlot, installDotMemReadme;
 var init_knowledge_runtime = __esm({
   "core/memory/knowledge-runtime.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_project_identity();
     init_user_paths();
@@ -9989,6 +10006,7 @@ async function getEntry(key) {
 var MEMORY_INDEX_KEY, SUPERSEDED_PREFIX, entries;
 var init_entries = __esm({
   "core/memory/entries.ts"() {
+    init_suppress_idb_warning();
     init_env();
     init_journal();
     MEMORY_INDEX_KEY = "__dotmem_memory_index__";
@@ -10341,6 +10359,7 @@ async function findClaimAcrossAllSources(claimId, scope, sourceProject) {
 var acquire;
 var init_acquire = __esm({
   "core/memory/acquire.ts"() {
+    init_suppress_idb_warning();
     init_env();
     init_project_identity();
     init_project_anchor();
@@ -11939,6 +11958,7 @@ async function bootstrapProject() {
 var pendingDetectionEvents, detectionFlushScheduled, flushDetectionEvents, memory;
 var init_memory = __esm({
   "core/memory/index.ts"() {
+    init_suppress_idb_warning();
     init_journal();
     init_brain();
     init_knowledge_runtime();
@@ -12845,6 +12865,7 @@ var init_policy3 = __esm({
 });
 
 // core/cli/index.ts
+init_suppress_idb_warning();
 init_memory();
 
 // core/continuity/freshness.ts
@@ -14225,7 +14246,7 @@ Run \`npx dotmem <command> --help\` for command-specific options.
 Memory:
   context "<situation>" [--explain] [--json] [--full] [--claims-only] [--limit <N>] [--format brief]
                               project acquired experience for a situation
-  init                         initialize dotmem for the current project (.mem/)
+  init                         initialize dotmem for the current project (.dotmem/)
   acquire                      acquire durable experience from a JSON claim on stdin
   learn "<text>" [--scope <user|project>] [--situation "<text>"] [--id "<id>"]
                               acquire a claim from plain text (shorthand for acquire)

package/global.cjs

@@ -21,6 +21,18 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// suppress-idb-warning.ts
+var orig;
+var init_suppress_idb_warning = __esm({
+  "suppress-idb-warning.ts"() {
+    orig = console.warn.bind(console);
+    console.warn = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("IndexedDB is not available")) return;
+      orig(...args);
+    };
+  }
+});
+
 // core/env.ts
 var DEV;
 var init_env = __esm({
@@ -4464,7 +4476,7 @@ function encodeMemFile(stateValue, preserved) {
 function decodeMemDocument(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid .mem file format");
   const file = value;
-  if (file.format !== MEM_FORMAT) throw new Error("Invalid .mem file format");
+  if (file.format !== MEM_FORMAT && file.format !== MEM_FORMAT_LEGACY) throw new Error("Invalid .mem file format");
   if (file.version === MEM_FORMAT_VERSION_V1) {
     if (!file.knowledge) throw new Error("Invalid .mem file format");
     return { state: validateSourceState(file.knowledge) };
@@ -4546,11 +4558,12 @@ function decodeMemDocument(value) {
     preserved: { map: structuredClone(map), data: structuredClone(stateRecord) }
   };
 }
-var MEM_FORMAT, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
+var MEM_FORMAT, MEM_FORMAT_LEGACY, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
 var init_mem_codec = __esm({
   "core/knowledge/mem-codec.ts"() {
     init_state();
     MEM_FORMAT = "dotmem.knowledge";
+    MEM_FORMAT_LEGACY = "memorio.knowledge";
     MEM_FORMAT_VERSION = 2;
     MEM_FORMAT_VERSION_V1 = 1;
     expectedFields = {
@@ -4656,12 +4669,13 @@ async function decodeMemArtifact(input) {
     throw new MemArtifactError(message.startsWith("Unsupported") ? "unsupported" : "invalid", message);
   }
 }
-var MEM_PACKAGE_FORMAT, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, encodePackage, isZip, decodePackage;
+var MEM_PACKAGE_FORMAT, MEM_PACKAGE_FORMAT_LEGACY, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, encodePackage, isZip, decodePackage;
 var init_mem_package = __esm({
   "core/knowledge/mem-package.ts"() {
     init_browser();
     init_mem_codec();
     MEM_PACKAGE_FORMAT = "dotmem.package";
+    MEM_PACKAGE_FORMAT_LEGACY = "memorio.package";
     MEM_PACKAGE_VERSION = 1;
     MEM_PACKAGE_LIMITS = Object.freeze({
       maximumPackageBytes: 10 * 1024 * 1024,
@@ -4835,10 +4849,10 @@ var init_mem_package = __esm({
         if (!parts[path]) throw new MemArtifactError("invalid", `Missing MEM package part: ${path}`);
       }
       const manifest = parseJson(parts[MANIFEST_PATH], MANIFEST_PATH);
-      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format || manifest.version !== MEM_PACKAGE_VERSION) {
+      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format !== MEM_PACKAGE_FORMAT_LEGACY || manifest.version !== MEM_PACKAGE_VERSION) {
         throw new MemArtifactError("unsupported", "Unsupported MEM package format or version");
       }
-      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
+      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format !== MEM_FORMAT_LEGACY || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
         throw new MemArtifactError("invalid", "Invalid MEM package manifest");
       }
       const integrity = parseJson(parts[INTEGRITY_PATH], INTEGRITY_PATH);
@@ -6706,6 +6720,7 @@ function _inferConfidence(claim) {
 var LOGIC_MEM_FILE, nodeCwd2, cachedRuntime, LogicEngine, logic, logic_default;
 var init_logic = __esm({
   "core/logic/index.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_mem_repository();
     init_acquisition_boundary();
@@ -6973,6 +6988,9 @@ Do not store secrets unless dotmem explicitly supports secure secret storage.
   }
 });
 
+// global.ts
+init_suppress_idb_warning();
+
 // core/idb.ts
 var idb = {
   db: {},
@@ -7242,7 +7260,11 @@ var security = {
   createSanitizer
 };
 
+// core/memory/index.ts
+init_suppress_idb_warning();
+
 // core/memory/journal.ts
+init_suppress_idb_warning();
 init_env();
 var g = globalThis;
 function namespace() {
@@ -7449,6 +7471,7 @@ var journal_default = journal;
 init_brain();
 
 // core/memory/knowledge-runtime.ts
+init_suppress_idb_warning();
 init_knowledge();
 init_project_identity();
 init_user_paths();
@@ -7797,6 +7820,7 @@ var policy = {
 };
 
 // core/memory/entries.ts
+init_suppress_idb_warning();
 init_env();
 var MEMORY_INDEX_KEY = "__dotmem_memory_index__";
 var SUPERSEDED_PREFIX = "__dotmem_superseded__";
@@ -8341,6 +8365,7 @@ var context = {
 };
 
 // core/memory/acquire.ts
+init_suppress_idb_warning();
 init_env();
 init_project_identity();
 init_project_anchor();

package/global.js

@@ -17,6 +17,18 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// suppress-idb-warning.ts
+var orig;
+var init_suppress_idb_warning = __esm({
+  "suppress-idb-warning.ts"() {
+    orig = console.warn.bind(console);
+    console.warn = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("IndexedDB is not available")) return;
+      orig(...args);
+    };
+  }
+});
+
 // core/env.ts
 var DEV;
 var init_env = __esm({
@@ -4460,7 +4472,7 @@ function encodeMemFile(stateValue, preserved) {
 function decodeMemDocument(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid .mem file format");
   const file = value;
-  if (file.format !== MEM_FORMAT) throw new Error("Invalid .mem file format");
+  if (file.format !== MEM_FORMAT && file.format !== MEM_FORMAT_LEGACY) throw new Error("Invalid .mem file format");
   if (file.version === MEM_FORMAT_VERSION_V1) {
     if (!file.knowledge) throw new Error("Invalid .mem file format");
     return { state: validateSourceState(file.knowledge) };
@@ -4542,11 +4554,12 @@ function decodeMemDocument(value) {
     preserved: { map: structuredClone(map), data: structuredClone(stateRecord) }
   };
 }
-var MEM_FORMAT, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
+var MEM_FORMAT, MEM_FORMAT_LEGACY, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
 var init_mem_codec = __esm({
   "core/knowledge/mem-codec.ts"() {
     init_state();
     MEM_FORMAT = "dotmem.knowledge";
+    MEM_FORMAT_LEGACY = "memorio.knowledge";
     MEM_FORMAT_VERSION = 2;
     MEM_FORMAT_VERSION_V1 = 1;
     expectedFields = {
@@ -4652,12 +4665,13 @@ async function decodeMemArtifact(input) {
     throw new MemArtifactError(message.startsWith("Unsupported") ? "unsupported" : "invalid", message);
   }
 }
-var MEM_PACKAGE_FORMAT, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, encodePackage, isZip, decodePackage;
+var MEM_PACKAGE_FORMAT, MEM_PACKAGE_FORMAT_LEGACY, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, encodePackage, isZip, decodePackage;
 var init_mem_package = __esm({
   "core/knowledge/mem-package.ts"() {
     init_browser();
     init_mem_codec();
     MEM_PACKAGE_FORMAT = "dotmem.package";
+    MEM_PACKAGE_FORMAT_LEGACY = "memorio.package";
     MEM_PACKAGE_VERSION = 1;
     MEM_PACKAGE_LIMITS = Object.freeze({
       maximumPackageBytes: 10 * 1024 * 1024,
@@ -4831,10 +4845,10 @@ var init_mem_package = __esm({
         if (!parts[path]) throw new MemArtifactError("invalid", `Missing MEM package part: ${path}`);
       }
       const manifest = parseJson(parts[MANIFEST_PATH], MANIFEST_PATH);
-      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format || manifest.version !== MEM_PACKAGE_VERSION) {
+      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format !== MEM_PACKAGE_FORMAT_LEGACY || manifest.version !== MEM_PACKAGE_VERSION) {
         throw new MemArtifactError("unsupported", "Unsupported MEM package format or version");
       }
-      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
+      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format !== MEM_FORMAT_LEGACY || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
         throw new MemArtifactError("invalid", "Invalid MEM package manifest");
       }
       const integrity = parseJson(parts[INTEGRITY_PATH], INTEGRITY_PATH);
@@ -6702,6 +6716,7 @@ function _inferConfidence(claim) {
 var LOGIC_MEM_FILE, nodeCwd2, cachedRuntime, LogicEngine, logic, logic_default;
 var init_logic = __esm({
   "core/logic/index.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_mem_repository();
     init_acquisition_boundary();
@@ -6969,6 +6984,9 @@ Do not store secrets unless dotmem explicitly supports secure secret storage.
   }
 });
 
+// global.ts
+init_suppress_idb_warning();
+
 // core/idb.ts
 var idb = {
   db: {},
@@ -7238,7 +7256,11 @@ var security = {
   createSanitizer
 };
 
+// core/memory/index.ts
+init_suppress_idb_warning();
+
 // core/memory/journal.ts
+init_suppress_idb_warning();
 init_env();
 var g = globalThis;
 function namespace() {
@@ -7445,6 +7467,7 @@ var journal_default = journal;
 init_brain();
 
 // core/memory/knowledge-runtime.ts
+init_suppress_idb_warning();
 init_knowledge();
 init_project_identity();
 init_user_paths();
@@ -7793,6 +7816,7 @@ var policy = {
 };
 
 // core/memory/entries.ts
+init_suppress_idb_warning();
 init_env();
 var MEMORY_INDEX_KEY = "__dotmem_memory_index__";
 var SUPERSEDED_PREFIX = "__dotmem_superseded__";
@@ -8337,6 +8361,7 @@ var context = {
 };
 
 // core/memory/acquire.ts
+init_suppress_idb_warning();
 init_env();
 init_project_identity();
 init_project_anchor();

package/index.cjs

@@ -22,6 +22,18 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// suppress-idb-warning.ts
+var orig;
+var init_suppress_idb_warning = __esm({
+  "suppress-idb-warning.ts"() {
+    orig = console.warn.bind(console);
+    console.warn = (...args) => {
+      if (typeof args[0] === "string" && args[0].includes("IndexedDB is not available")) return;
+      orig(...args);
+    };
+  }
+});
+
 // core/env.ts
 var DEV;
 var init_env = __esm({
@@ -4473,7 +4485,7 @@ function encodeMemFile(stateValue, preserved) {
 function decodeMemDocument(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid .mem file format");
   const file = value;
-  if (file.format !== MEM_FORMAT) throw new Error("Invalid .mem file format");
+  if (file.format !== MEM_FORMAT && file.format !== MEM_FORMAT_LEGACY) throw new Error("Invalid .mem file format");
   if (file.version === MEM_FORMAT_VERSION_V1) {
     if (!file.knowledge) throw new Error("Invalid .mem file format");
     return { state: validateSourceState(file.knowledge) };
@@ -4555,11 +4567,12 @@ function decodeMemDocument(value) {
     preserved: { map: structuredClone(map), data: structuredClone(stateRecord) }
   };
 }
-var MEM_FORMAT, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
+var MEM_FORMAT, MEM_FORMAT_LEGACY, MEM_FORMAT_VERSION, MEM_FORMAT_VERSION_V1, expectedFields, epistemicTypes, revisionKinds, claimKinds, isJsonValue2, createMemInterpretationMap, validateSourceState, trimRecord, fieldIndexes, validateVocabulary, put, get, optionalGet, requireRecord, putOptional;
 var init_mem_codec = __esm({
   "core/knowledge/mem-codec.ts"() {
     init_state();
     MEM_FORMAT = "dotmem.knowledge";
+    MEM_FORMAT_LEGACY = "memorio.knowledge";
     MEM_FORMAT_VERSION = 2;
     MEM_FORMAT_VERSION_V1 = 1;
     expectedFields = {
@@ -4738,12 +4751,13 @@ async function inspectMem(input) {
     return { status: artifactError.code, representation: "unknown", message: artifactError.message, parts: [] };
   }
 }
-var MEM_PACKAGE_FORMAT, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlEncode, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
+var MEM_PACKAGE_FORMAT, MEM_PACKAGE_FORMAT_LEGACY, MEM_PACKAGE_VERSION, MEM_PACKAGE_LIMITS, MEM_PACKAGE_WRITE_MARGIN_BYTES, MEM_PACKAGE_WRITE_LIMITS, MANIFEST_PATH, MAP_PATH, DATA_PATH, INTEGRITY_PATH, requiredParts, encoder2, decoder, MemArtifactError, stableValue, jsonBytes, sha256, parseJson, validEntryPath, concatenate, readZipParts, createManifest, digestTableIdentity, signaturePayload, base64UrlEncode, base64UrlDecode, keyIdentity, signaturePath, encodePackage, isZip, decodePackage, verifySignature;
 var init_mem_package = __esm({
   "core/knowledge/mem-package.ts"() {
     init_browser();
     init_mem_codec();
     MEM_PACKAGE_FORMAT = "dotmem.package";
+    MEM_PACKAGE_FORMAT_LEGACY = "memorio.package";
     MEM_PACKAGE_VERSION = 1;
     MEM_PACKAGE_LIMITS = Object.freeze({
       maximumPackageBytes: 10 * 1024 * 1024,
@@ -4934,10 +4948,10 @@ ${contentId}
         if (!parts[path]) throw new MemArtifactError("invalid", `Missing MEM package part: ${path}`);
       }
       const manifest = parseJson(parts[MANIFEST_PATH], MANIFEST_PATH);
-      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format || manifest.version !== MEM_PACKAGE_VERSION) {
+      if (manifest.format !== MEM_PACKAGE_FORMAT && manifest.format !== MEM_PACKAGE_FORMAT_LEGACY || manifest.version !== MEM_PACKAGE_VERSION) {
         throw new MemArtifactError("unsupported", "Unsupported MEM package format or version");
       }
-      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
+      if (manifest.memory?.format !== MEM_FORMAT && manifest.memory?.format !== MEM_FORMAT_LEGACY || manifest.memory.version !== MEM_FORMAT_VERSION || manifest.parts?.map !== MAP_PATH || manifest.parts?.data !== DATA_PATH || manifest.parts?.integrity !== INTEGRITY_PATH) {
         throw new MemArtifactError("invalid", "Invalid MEM package manifest");
       }
       const integrity = parseJson(parts[INTEGRITY_PATH], INTEGRITY_PATH);
@@ -6961,6 +6975,7 @@ function _inferConfidence(claim) {
 var LOGIC_MEM_FILE, nodeCwd2, cachedRuntime, LogicEngine, logic, logic_default;
 var init_logic = __esm({
   "core/logic/index.ts"() {
+    init_suppress_idb_warning();
     init_knowledge();
     init_mem_repository();
     init_acquisition_boundary();
@@ -7228,6 +7243,9 @@ Do not store secrets unless dotmem explicitly supports secure secret storage.
   }
 });
 
+// index.ts
+init_suppress_idb_warning();
+
 // core/idb.ts
 var idb = {
   db: {},
@@ -7567,7 +7585,11 @@ var security = {
   createSanitizer
 };
 
+// core/memory/index.ts
+init_suppress_idb_warning();
+
 // core/memory/journal.ts
+init_suppress_idb_warning();
 init_env();
 var g = globalThis;
 function namespace() {
@@ -7774,6 +7796,7 @@ var journal_default = journal;
 init_brain();
 
 // core/memory/knowledge-runtime.ts
+init_suppress_idb_warning();
 init_knowledge();
 init_project_identity();
 init_user_paths();
@@ -8122,6 +8145,7 @@ var policy = {
 };
 
 // core/memory/entries.ts
+init_suppress_idb_warning();
 init_env();
 var MEMORY_INDEX_KEY = "__dotmem_memory_index__";
 var SUPERSEDED_PREFIX = "__dotmem_superseded__";
@@ -8666,6 +8690,7 @@ var context = {
 };
 
 // core/memory/acquire.ts
+init_suppress_idb_warning();
 init_env();
 init_project_identity();
 init_project_anchor();