arcane-os 0.28.0 → 0.28.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.28.1
+
+- DBOPFS initialization opens the application's existing storage scope without
+  creating product-specific table directories. Applications create the tables
+  they need through the existing `getTableHandle(name)` API after readiness.
+- Create tables on demand and coalesce concurrent requests for the same physical
+  table. Logical `memories` and physical `memory` retain one shared handle and
+  deletion path. Existing directory discovery, complete reads and exports, CRUD,
+  worker fallback, events, application identity and saved data remain supported.
+- Explicit `clearAllStorage()` leaves the cleared application scope empty rather
+  than recreating default folders. This update performs no saved-data migration
+  or automatic removal of existing folders. The 0.28.0 npm resource paths remain
+  unchanged.
+
 ## 0.28.0
 
 - Expose existing runtime modules and entities directly through

package/README.md

@@ -19,7 +19,7 @@ version-locked SDK runtime, while an integrated Arcane checkout uses its live
 `arcane/` runtime. Both profiles preserve the same app URLs, theme, packaging,
 event, cancellation, and browser run contracts.
 
-This checkout defines the `0.28.0` SDK contract. Applications pin one exact npm
+This checkout defines the `0.28.1` SDK contract. Applications pin one exact npm
 version and lockfile; registry state is deliberately not baked into application
 artifacts.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/runtime/arcane/components/file-manager.html

@@ -1905,7 +1905,7 @@
         let tableNames=dirs;
 
         if(!tableNames?.length){
-            tableNames=await dbopfs.getTableNames(Boolean(layout));
+            tableNames=await dbopfs.getTableNames(true);
         }
         if(destroyed||sequence!==gridLoadSequence){
             return [];

package/runtime/arcane/modules/DBOPFS.js

@@ -16,20 +16,20 @@ const dbopfsReasons={
 export const DBOPFS_EVENT_TYPES={...dbopfsEventTypes};
 export const DBOPFS_REASONS={...dbopfsReasons};
 
-const DEFAULT_TABLE_DIRECTORIES={
-    users:'users',
-    scores:'scores',
-    chats:'chats',
-    notes:'notes',
-    documents:'documents',
-    songs:'songs',
-    images:'images',
-    journal_entries:'journal_entries',
-    streams_of_consciousness:'streams_of_consciousness',
-    reports:'reports',
-    errors:'errors',
+const TABLE_DIRECTORY_ALIASES={
     memories:'memory'
 };
+const DIRECTORY_TABLE_ALIASES={
+    memory:'memories'
+};
+
+function directoryNameForTable(tableName=''){
+    return TABLE_DIRECTORY_ALIASES[tableName]||tableName;
+}
+
+function tableNameForDirectory(directoryName=''){
+    return DIRECTORY_TABLE_ALIASES[directoryName]||directoryName;
+}
 
 function parseFileValue(fileName='',textContent=''){
     let value=textContent;
@@ -79,6 +79,11 @@ if(navigator.storage?.persist){
  * Handles to directories inside OPFS.
  */
 
+/**
+ * @typedef {Object<string,Promise<FileSystemDirectoryHandle>>} DBOPFSTableHandlePromises
+ * Pending table handle requests keyed by logical table name.
+ */
+
 /**
  * @typedef {Object<string,Promise>} DBOPFSWriteLocks
  * Promise based write locks to serialize writes to the same file.
@@ -119,6 +124,9 @@ class DBOPFS {
     /** @type {DBOPFSTableHandles} */
     #tableHandles={}
 
+    /** @type {DBOPFSTableHandlePromises} */
+    #tableHandlePromises={}
+
     /** @type {DBOPFSTables} */
     #tables={}
 
@@ -297,7 +305,7 @@ class DBOPFS {
     }
 
     /**
-     * Initializes OPFS database and default tables.
+     * Initializes the application OPFS database scope.
      * Dispatches `dbopfs-ready` event when complete.
      *
      * @returns {Promise<void>}
@@ -313,7 +321,6 @@ class DBOPFS {
         this.#applicationId=scope.applicationId;
         this.#storagePath=scope.path;
         this.#db=scope.directory;
-        await this.#createDefaultTables();
 
         this.ready=true;
 
@@ -338,15 +345,6 @@ class DBOPFS {
         projectArcaneDOMEvent(window,occurrence);
     }
 
-    async #createDefaultTables(){
-        for(const [alias,directoryName]of Object.entries(DEFAULT_TABLE_DIRECTORIES)){
-            this.#tableHandles[alias]=await this.#db.getDirectoryHandle(
-                directoryName,
-                {create:true}
-            );
-        }
-    }
-
     /**
      * Canonical application identity owning this database.
      *
@@ -403,19 +401,49 @@ class DBOPFS {
             await this.readyPromise;
         }
 
-        if(!this.#tableHandles[tableName]){
-            const existingHandle=Object.values(this.#tableHandles).find(
-                handle=>handle.name===tableName
-            )
+        const directoryName=directoryNameForTable(tableName);
+        const registeredTableName=tableNameForDirectory(directoryName);
 
-            if(existingHandle){
-                return existingHandle
+        if(this.#tableHandles[registeredTableName]){
+            return this.#tableHandles[registeredTableName];
+        }
+
+        const existingHandle=Object.values(this.#tableHandles).find(
+            function matchingTableDirectory(handle){
+                return handle.name===directoryName;
             }
+        );
 
-            this.#tableHandles[tableName]=await this.#db.getDirectoryHandle(tableName,{create:true});
+        if(existingHandle){
+            this.#tableHandles[registeredTableName]=existingHandle;
+            return existingHandle;
         }
 
-        return this.#tableHandles[tableName];
+        if(!this.#tableHandlePromises[registeredTableName]){
+            const handlePromise=this.#db.getDirectoryHandle(
+                directoryName,
+                {create:true}
+            ).then(
+                function registerRequestedTable(handle){
+                    this.#tableHandles[registeredTableName]=handle;
+                    return handle;
+                }.bind(this)
+            );
+            this.#tableHandlePromises[registeredTableName]=handlePromise;
+
+            function clearTableHandlePromise(){
+                if(this.#tableHandlePromises[registeredTableName]===handlePromise){
+                    delete this.#tableHandlePromises[registeredTableName];
+                }
+            }
+
+            handlePromise.then(
+                clearTableHandlePromise.bind(this),
+                clearTableHandlePromise.bind(this)
+            );
+        }
+
+        return this.#tableHandlePromises[registeredTableName];
     }
 
     /**
@@ -779,11 +807,17 @@ class DBOPFS {
      * @returns {Promise<boolean>}
      */
     async deleteTable(tableName){
+        const directoryName=directoryNameForTable(tableName);
+        const registeredTableName=tableNameForDirectory(directoryName);
+
         try{
-            await this.#db.removeEntry(tableName,{recursive:true})
+            await this.#db.removeEntry(directoryName,{recursive:true})
 
             delete this.#tables[tableName]
-            delete this.#tableHandles[tableName]
+            delete this.#tables[directoryName]
+            delete this.#tables[registeredTableName]
+            delete this.#tableHandles[registeredTableName]
+            delete this.#tableHandlePromises[registeredTableName]
         }catch(error){
             arcaneLogging.error(error)
         }
@@ -807,8 +841,8 @@ class DBOPFS {
 
         this.#tables={}
         this.#tableHandles={}
+        this.#tableHandlePromises={}
         this.#writeLocks={}
-        await this.#createDefaultTables()
 
         return this
     }
@@ -864,12 +898,15 @@ class DBOPFS {
                 continue
             }
 
+            const registeredTableName=tableNameForDirectory(name);
             const registered=Object.values(this.#tableHandles).some(
-                tableHandle=>tableHandle.name===name
-            )
+                function matchingDiscoveredDirectory(tableHandle){
+                    return tableHandle.name===name;
+                }
+            );
 
             if(!registered){
-                this.#tableHandles[name]=handle
+                this.#tableHandles[registeredTableName]=handle
             }
 
             tableNames.push(name)