luajitos

RamDisk.lua (29278B)

---

 
 local RamDisk = {}
 
 -- Node metatable for directories
 local dirNode = {}
 dirNode.__index = dirNode
 
 -- Node metatable for files
 local fileNode = {}
 fileNode.__index = fileNode
 
 -- Helper function to split path into components
 local function splitPath(path)
     local components = {}
     -- Remove leading slash if present
     path = path:gsub("^/+", "")
     -- Split by slash
     for component in path:gmatch("[^/]+") do
         table.insert(components, component)
     end
     return components
 end
 
 -- Helper function to find root node
 local function findRoot(node)
     while node.parent ~= nil do
         node = node.parent
     end
     return node
 end
 
 -- Traverse method for both file and directory nodes (absolute paths from root)
 local function traverse(self, path)
     -- Start from root
     local root = findRoot(self)
     local current = root
 
     -- Split path into components
     local components = splitPath(path)
 
     -- Traverse through each component
     for i, component in ipairs(components) do
         if current.type ~= "directory" then
             return nil, "not a directory: " .. current.name
         end
 
         -- Check if this is the last component
         local isLast = (i == #components)
 
         -- Search in directories first
         local found = false
         for _, dir in ipairs(current.dirs) do
             if dir.name == component then
                 current = dir
                 found = true
                 break
             end
         end
 
         -- If not found in dirs and this is the last component, check files
         if not found and isLast then
             for _, file in ipairs(current.files) do
                 if file.name == component then
                     current = file
                     found = true
                     break
                 end
             end
         end
 
         -- If still not found, check in dirs for last component (could be a directory)
         if not found then
             return nil, "path not found: " .. component
         end
     end
 
     return current
 end
 
 -- Find method for both file and directory nodes (supports relative paths)
 local function find(self, path)
     -- Check if path starts with / (absolute path)
     if path:sub(1, 1) == "/" then
         -- Absolute path - start from root
         return traverse(self, path)
     end
 
     -- Relative path - start from current node
     local current = self
 
     -- Split path into components
     local components = splitPath(path)
 
     -- Traverse through each component
     for i, component in ipairs(components) do
         if current.type ~= "directory" then
             return nil, "not a directory: " .. current.name
         end
 
         -- Check if this is the last component
         local isLast = (i == #components)
 
         -- Search in directories first
         local found = false
         for _, dir in ipairs(current.dirs) do
             if dir.name == component then
                 current = dir
                 found = true
                 break
             end
         end
 
         -- If not found in dirs and this is the last component, check files
         if not found and isLast then
             for _, file in ipairs(current.files) do
                 if file.name == component then
                     current = file
                     found = true
                     break
                 end
             end
         end
 
         -- If still not found, return nil
         if not found then
             return nil, "path not found: " .. component
         end
     end
 
     return current
 end
 
 -- Method to create a new directory
 function dirNode:newDir(name)
     local dir = {
         name = name,
         type = "directory",
         parent = self,
         dirs = {},
         files = {}
     }
     setmetatable(dir, dirNode)
     table.insert(self.dirs, dir)
     return dir
 end
 
 -- Method to create a new file
 function dirNode:newFile(name, contents)
     local file = {
         name = name,
         type = "file",
         parent = self,
         contents = contents or ""
     }
     setmetatable(file, fileNode)
     table.insert(self.files, file)
     return file
 end
 
 -- Read method for files
 function fileNode:read()
     return self.contents
 end
 
 -- Write method for files
 function fileNode:write(contents)
     self.contents = contents
 end
 
 -- Delete method for files
 function fileNode:delete()
     if self.parent then
         -- Remove from parent's files array
         for i, file in ipairs(self.parent.files) do
             if file == self then
                 table.remove(self.parent.files, i)
                 break
             end
         end
     end
     -- Clear file data
     self.name = nil
     self.parent = nil
     self.contents = nil
 end
 
 -- Delete method for directories
 function dirNode:delete()
     if self.parent then
         -- Remove from parent's dirs array
         for i, dir in ipairs(self.parent.dirs) do
             if dir == self then
                 table.remove(self.parent.dirs, i)
                 break
             end
         end
     end
     -- Clear directory data
     self.name = nil
     self.parent = nil
     -- Note: dirs and files arrays are left for garbage collection
 end
 
 -- Add traverse and find methods to both metatables
 dirNode.traverse = traverse
 fileNode.traverse = traverse
 dirNode.find = find
 fileNode.find = find
 
 -- Function to create a root directory node
 local function createRoot()
     local root = {
         name = "",
         type = "directory",
         parent = nil,
         dirs = {},
         files = {}
     }
     setmetatable(root, dirNode)
     return root
 end
 
 -- Helper function to get full path of a node
 local function getFullPath(node)
     local parts = {}
     local current = node
 
     while current.parent ~= nil do
         table.insert(parts, 1, current.name)
         current = current.parent
     end
 
     return table.concat(parts, "/")
 end
 
 -- Helper function to check if content is binary (contains non-printable chars)
 local function isBinary(content)
     if type(content) ~= "string" then
         return false
     end
 
     for i = 1, #content do
         local byte = content:byte(i)
         -- Check for control characters except tab, newline, carriage return
         if byte < 32 and byte ~= 9 and byte ~= 10 and byte ~= 13 then
             return true
         end
         -- Check for extended ASCII
         if byte > 127 then
             return true
         end
     end
     return false
 end
 
 -- Helper function to find character position in base64 alphabet
 local function base64CharPos(c)
     local b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
     for i = 1, 64 do
         if b:sub(i, i) == c then
             return i - 1
         end
     end
     return nil
 end
 
 -- Helper function to encode binary data to base64
 local function base64Encode(data)
     local b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
     local result = {}
     local bit = require("bit")
 
     -- Process 3 bytes at a time
     for i = 1, #data, 3 do
         local b1 = string.byte(data, i)
         local b2 = string.byte(data, i + 1)
         local b3 = string.byte(data, i + 2)
 
         -- First 6 bits from b1
         local c1 = b:sub(bit.rshift(b1, 2) + 1, bit.rshift(b1, 2) + 1)
 
         if b2 then
             -- Last 2 bits of b1 + first 4 bits of b2
             local c2 = b:sub(bit.bor(bit.lshift(bit.band(b1, 0x03), 4), bit.rshift(b2, 4)) + 1, bit.bor(bit.lshift(bit.band(b1, 0x03), 4), bit.rshift(b2, 4)) + 1)
 
             if b3 then
                 -- Last 4 bits of b2 + first 2 bits of b3
                 local c3 = b:sub(bit.bor(bit.lshift(bit.band(b2, 0x0F), 2), bit.rshift(b3, 6)) + 1, bit.bor(bit.lshift(bit.band(b2, 0x0F), 2), bit.rshift(b3, 6)) + 1)
                 -- Last 6 bits of b3
                 local c4 = b:sub(bit.band(b3, 0x3F) + 1, bit.band(b3, 0x3F) + 1)
                 table.insert(result, c1 .. c2 .. c3 .. c4)
             else
                 -- Last 4 bits of b2, padded
                 local c3 = b:sub(bit.lshift(bit.band(b2, 0x0F), 2) + 1, bit.lshift(bit.band(b2, 0x0F), 2) + 1)
                 table.insert(result, c1 .. c2 .. c3 .. '=')
             end
         else
             -- Last 2 bits of b1, padded
             local c2 = b:sub(bit.lshift(bit.band(b1, 0x03), 4) + 1, bit.lshift(bit.band(b1, 0x03), 4) + 1)
             table.insert(result, c1 .. c2 .. '==')
         end
     end
 
     return table.concat(result)
 end
 
 -- Helper function to decode base64 to binary data
 local function base64Decode(data)
     osprint("base64Decode: Starting decode, data length = ")
     osprint(tostring(#data))
     osprint("\n")
 
     local result = {}
     local dataLen = #data
     local bit = require("bit")
 
     -- Process 4 characters at a time
     for i = 1, dataLen, 4 do
         local c1 = data:sub(i, i)
         local c2 = data:sub(i + 1, i + 1)
         local c3 = data:sub(i + 2, i + 2)
         local c4 = data:sub(i + 3, i + 3)
 
         osprint("base64Decode: Processing position ")
         osprint(tostring(i))
         osprint("\n")
 
         -- Decode first two chars (always present)
         local v1 = base64CharPos(c1)
         local v2 = base64CharPos(c2)
 
         if v1 and v2 then
             -- First byte: 6 bits from v1 + 2 bits from v2
             local b1 = bit.bor(bit.lshift(v1, 2), bit.rshift(v2, 4))
             table.insert(result, string.char(b1))
 
             -- Check for padding
             if c3 ~= '=' then
                 local v3 = base64CharPos(c3)
                 if v3 then
                     -- Second byte: 4 bits from v2 + 4 bits from v3
                     local b2 = bit.bor(bit.lshift(bit.band(v2, 0x0F), 4), bit.rshift(v3, 2))
                     table.insert(result, string.char(b2))
 
                     if c4 ~= '=' then
                         local v4 = base64CharPos(c4)
                         if v4 then
                             -- Third byte: 2 bits from v3 + 6 bits from v4
                             local b3 = bit.bor(bit.lshift(bit.band(v3, 0x03), 6), v4)
                             table.insert(result, string.char(b3))
                         end
                     end
                 end
             end
         end
 
         if i % 100 == 0 then
             osprint("base64Decode: Progress ")
             osprint(tostring(i))
             osprint("/")
             osprint(tostring(dataLen))
             osprint("\n")
         end
     end
 
     osprint("base64Decode: Completed\n")
     return table.concat(result)
 end
 
 -- Helper function to escape special characters in text content
 local function escapeText(text)
     local result = {}
     for i = 1, #text do
         local c = text:sub(i, i)
         if c == "\\" then
             table.insert(result, "\\\\")
         elseif c == "\n" then
             table.insert(result, "\\n")
         elseif c == "\t" then
             table.insert(result, "\\t")
         elseif c == "\r" then
             table.insert(result, "\\r")
         else
             table.insert(result, c)
         end
     end
     return table.concat(result)
 end
 
 -- Helper function to unescape special characters in text content
 local function unescapeText(text)
     osprint("unescapeText: Starting, length = ")
     osprint(tostring(#text))
     osprint("\n")
 
     local result = {}
     local i = 1
     local textLen = #text
 
     while i <= textLen do
         local c = text:sub(i, i)
         if c == "\\" and i < textLen then
             local next = text:sub(i + 1, i + 1)
             if next == "r" then
                 table.insert(result, "\r")
                 i = i + 2
             elseif next == "t" then
                 table.insert(result, "\t")
                 i = i + 2
             elseif next == "n" then
                 table.insert(result, "\n")
                 i = i + 2
             elseif next == "\\" then
                 table.insert(result, "\\")
                 i = i + 2
             else
                 table.insert(result, c)
                 i = i + 1
             end
         else
             table.insert(result, c)
             i = i + 1
         end
     end
 
     osprint("unescapeText: Completed\n")
     return table.concat(result)
 end
 
 -- Function to save the filesystem to serialized format
 local function saveFS(rootdir)
     local dirs = {}
     local files = {}
 
     -- Recursive function to traverse directories
     local function traverseDir(dir, currentPath)
         -- Add directory path (with trailing slash)
         if currentPath ~= "" then
             table.insert(dirs, currentPath .. "/")
         end
 
         -- Process subdirectories
         for _, subdir in ipairs(dir.dirs) do
             local subdirPath = currentPath == "" and subdir.name or currentPath .. "/" .. subdir.name
             traverseDir(subdir, subdirPath)
         end
 
         -- Process files
         for _, file in ipairs(dir.files) do
             local filePath = currentPath == "" and file.name or currentPath .. "/" .. file.name
             local contents = file.contents or ""
 
             if isBinary(contents) then
                 table.insert(files, filePath .. "~~".."~~BIN:" .. base64Encode(contents))
             else
                 table.insert(files, filePath .. "~~".."~~" .. escapeText(contents))
             end
         end
     end
 
     -- Start traversal from root
     traverseDir(rootdir, "")
 
     -- Build the final format: [[dirs||||files]]
     local dirSection = table.concat(dirs, "||".."||")
     local fileSection = table.concat(files, "||".."||")
 
     return "[[" .. dirSection .. "||".."||" .. fileSection .. "]]"
 end
 
 -- Function to load a filesystem from serialized format
 local function loadFS(serialized)
     osprint("loadFS: Creating root\n")
     -- Create new root
     local root = createRoot()
 
     osprint("loadFS: Processing content\n")
     -- The serialized data is already in the raw format (no [[ ]] wrapper)
     local content = serialized
 
     osprint("loadFS: Splitting entries\n")
     -- Split by |||| to separate entries (optimized with table for string building)
     local entries = {}
     local currentEntry = {}
     local i = 1
     local content_len = #content
 
     while i <= content_len do
         -- Check if we're at a |||| separator
         if i + 3 <= content_len and content:sub(i, i+3) == "||".."||" then
             if #currentEntry > 0 then
                 table.insert(entries, table.concat(currentEntry))
                 currentEntry = {}
             end
             i = i + 4  -- Skip the ||||
         else
             table.insert(currentEntry, content:sub(i, i))
             i = i + 1
         end
     end
     -- Don't forget the last entry
     if #currentEntry > 0 then
         table.insert(entries, table.concat(currentEntry))
     end
 
     osprint("loadFS: Found ")
     osprint(tostring(#entries))
     osprint(" entries\n")
 
     -- Track created directories
     local createdDirs = {}
     createdDirs[""] = root  -- Root is always available
 
     -- Helper to ensure directory exists
     local function ensureDir(path)
         if createdDirs[path] then
             return createdDirs[path]
         end
 
         -- Split path into components
         local components = splitPath(path)
         local current = root
         local currentPath = ""
 
         for _, component in ipairs(components) do
             local nextPath = currentPath == "" and component or currentPath .. "/" .. component
 
             if not createdDirs[nextPath] then
                 -- Check if directory already exists
                 local found = false
                 for _, dir in ipairs(current.dirs) do
                     if dir.name == component then
                         current = dir
                         found = true
                         break
                     end
                 end
 
                 if not found then
                     current = current:newDir(component)
                 end
 
                 createdDirs[nextPath] = current
             else
                 current = createdDirs[nextPath]
             end
 
             currentPath = nextPath
         end
 
         return current
     end
 
     -- First pass: create all directories
     osprint("loadFS: Creating directories...\n")
     for i, entry in ipairs(entries) do
         osprint("loadFS: Processing entry ")
         osprint(tostring(i))
         osprint("\n")
         -- Check if ends with "/" by looking at last character
         if #entry > 0 and entry:sub(-1, -1) == "/" then  -- It's a directory
             osprint("loadFS: Found directory: ")
             osprint(entry)
             osprint("\n")
             local dirPath = entry:sub(1, -2)  -- Remove trailing slash
             ensureDir(dirPath)
         end
     end
     osprint("loadFS: All directories created\n")
 
     -- Second pass: create all files
     osprint("loadFS: Creating files...\n")
     for i, entry in ipairs(entries) do
         -- Check if contains ~~~~ by manual search
         local separatorPos = nil
         for j = 1, #entry - 3 do
             if entry:sub(j, j+3) == "~~".."~~" then
                 separatorPos = j
                 break
             end
         end
 
         if separatorPos then  -- It's a file
             osprint("loadFS: Processing file entry ")
             osprint(tostring(i))
             osprint("\n")
 
             local filePath = entry:sub(1, separatorPos - 1)
             local fileContent = entry:sub(separatorPos + 4)
 
             osprint("loadFS: File path: ")
             osprint(filePath)
             osprint("\n")
 
             -- Determine parent directory and filename by finding last /
             local lastSlash = nil
             for j = #filePath, 1, -1 do
                 if filePath:sub(j, j) == "/" then
                     lastSlash = j
                     break
                 end
             end
 
             local parentPath, fileName
             if lastSlash then
                 parentPath = filePath:sub(1, lastSlash - 1)
                 fileName = filePath:sub(lastSlash + 1)
             else
                 parentPath = ""
                 fileName = filePath
             end
 
             osprint("loadFS: Parent path: [")
             osprint(parentPath)
             osprint("] File name: [")
             osprint(fileName)
             osprint("]\n")
 
             -- Get or create parent directory
             local parentDir = ensureDir(parentPath)
 
             -- Check if it's binary by looking at first 4 chars
             if #fileContent >= 4 and fileContent:sub(1, 4) == "BIN:" then
                 osprint("loadFS: Binary file, decoding...\n")
                 local base64Data = fileContent:sub(5)  -- Remove "BIN:" prefix
                 local binaryContent = base64Decode(base64Data)
                 parentDir:newFile(fileName, binaryContent)
             else
                 osprint("loadFS: Text file, unescaping...\n")
                 local textContent = unescapeText(fileContent)
                 parentDir:newFile(fileName, textContent)
             end
             osprint("loadFS: File created\n")
         end
     end
     osprint("loadFS: All files created\n")
 
     return root
 end
 
 -- Initialize the filesystem from ramdisk_packed provided by C
 -- ramdisk_packed is expected to be a global string set by the C kernel
 local root_fs
 
 if ramdisk_packed and type(ramdisk_packed) == "string" and #ramdisk_packed > 0 then
     -- Load filesystem from the packed ramdisk string
     osprint("Loading filesystem from ramdisk_packed...\n")
     osprint("Ramdisk size: ")
     osprint(tostring(#ramdisk_packed))
     osprint(" bytes\n")
 
     osprint("About to call loadFS...\n")
     local success, result = pcall(loadFS, ramdisk_packed)
     osprint("loadFS call completed\n")
 
     if success then
         root_fs = result
         osprint("Filesystem loaded successfully!\n")
     else
         osprint("Error loading filesystem: ")
         osprint(tostring(result))
         osprint("\n")
         osprint("Creating empty root filesystem...\n")
         root_fs = createRoot()
     end
 else
     -- No ramdisk_packed provided, create empty filesystem
     osprint("No ramdisk_packed found, creating empty root filesystem...\n")
     root_fs = createRoot()
 end
 
 -- Make the root filesystem and utility functions globally available
 _G.root_fs = root_fs
 _G.createRoot = createRoot
 _G.saveFS = saveFS
 _G.loadFS = loadFS
 
 -- File Handle System
 -- Provides io.open() compatible file handles with read/write methods
 
 local FileHandle = {}
 FileHandle.__index = FileHandle
 
 function FileHandle:read(format)
     if not self.node or self.node.type ~= "file" then
         return nil, "invalid file handle"
     end
 
     if self.mode ~= "r" and self.mode ~= "r+" and self.mode ~= "a+" then
         return nil, "file not opened for reading"
     end
 
     format = format or "*l"  -- default: read line
 
     -- Handle pseudo files
     local content
     if self.node.isPseudo then
         if self.node.onRead then
             -- Get arguments from temporary storage if present
             local args = self.node._tempArgs
             if args then
                 content = self.node.onRead(args)
                 -- Clear temporary args after use
                 self.node._tempArgs = nil
             else
                 content = self.node.onRead()
             end
             content = content or ""
         else
             return nil, "Pseudo file has no onRead callback"
         end
     else
         content = self.node.contents or ""
     end
 
     if format == "*a" or format == "*all" then
         -- Read entire file
         self.position = #content
         return content
     elseif format == "*l" or format == "*line" then
         -- Read single line
         if self.position >= #content then
             return nil  -- EOF
         end
 
         local start_pos = self.position + 1
         local newline_pos = content:find("\n", start_pos, true)
 
         if newline_pos then
             local line = content:sub(start_pos, newline_pos - 1)
             self.position = newline_pos
             return line
         else
             -- Last line without newline
             local line = content:sub(start_pos)
             self.position = #content
             return line
         end
     elseif format == "*n" or format == "*number" then
         -- Read number
         if self.position >= #content then
             return nil
         end
 
         -- Skip whitespace
         local start_pos = self.position + 1
         while start_pos <= #content and content:sub(start_pos, start_pos):match("%s") do
             start_pos = start_pos + 1
         end
 
         if start_pos > #content then
             return nil
         end
 
         -- Read number
         local num_match = content:sub(start_pos):match("^[+-]?%d+%.?%d*")
         if num_match then
             self.position = start_pos + #num_match - 1
             return tonumber(num_match)
         end
 
         return nil
     elseif type(format) == "number" then
         -- Read n bytes
         if self.position >= #content then
             return nil
         end
 
         local start_pos = self.position + 1
         local end_pos = math.min(start_pos + format - 1, #content)
         local data = content:sub(start_pos, end_pos)
         self.position = end_pos
         return data
     else
         return nil, "invalid format"
     end
 end
 
 function FileHandle:write(...)
     if not self.node or self.node.type ~= "file" then
         return nil, "invalid file handle"
     end
 
     if self.mode ~= "w" and self.mode ~= "a" and self.mode ~= "r+" and self.mode ~= "a+" then
         return nil, "file not opened for writing"
     end
 
     local args = {...}
     for _, data in ipairs(args) do
         local str = tostring(data)
 
         if self.mode == "w" or self.mode == "r+" then
             -- Write mode: insert at current position
             local content = self.node.contents or ""
             local before = content:sub(1, self.position)
             local after = content:sub(self.position + #str + 1)
             self.node.contents = before .. str .. after
             self.position = self.position + #str
         elseif self.mode == "a" or self.mode == "a+" then
             -- Append mode: always append to end
             self.node.contents = (self.node.contents or "") .. str
             self.position = #self.node.contents
         end
     end
 
     return self
 end
 
 function FileHandle:lines()
     if not self.node or self.node.type ~= "file" then
         return function() return nil end
     end
 
     if self.mode ~= "r" and self.mode ~= "r+" and self.mode ~= "a+" then
         return function() return nil end
     end
 
     -- Reset position for iteration
     self.position = 0
 
     return function()
         return self:read("*l")
     end
 end
 
 function FileHandle:seek(whence, offset)
     if not self.node or self.node.type ~= "file" then
         return nil, "invalid file handle"
     end
 
     whence = whence or "cur"
     offset = offset or 0
 
     local content_length = #(self.node.contents or "")
 
     if whence == "set" then
         self.position = offset
     elseif whence == "cur" then
         self.position = self.position + offset
     elseif whence == "end" then
         self.position = content_length + offset
     else
         return nil, "invalid whence"
     end
 
     -- Clamp position
     self.position = math.max(0, math.min(self.position, content_length))
 
     return self.position
 end
 
 function FileHandle:close()
     self.node = nil
     self.mode = nil
     self.position = nil
     return true
 end
 
 function FileHandle:flush()
     -- No-op for in-memory filesystem
     return true
 end
 
 -- io.open() implementation
 local function io_open(filepath, mode)
     mode = mode or "r"
 
     -- Validate mode
     if not mode:match("^[rwa]%+?b?$") then
         return nil, "invalid mode"
     end
 
     -- Remove binary flag (we don't distinguish in ramdisk)
     mode = mode:gsub("b", "")
 
     -- Check if filepath contains arguments (space after filename)
     local actualPath = filepath
     local args = nil
     local spacePos = filepath:find(" ")
 
     if spacePos then
         actualPath = filepath:sub(1, spacePos - 1)
         args = filepath:sub(spacePos + 1)
     end
 
     local node, err
 
     if mode:sub(1, 1) == "r" then
         -- Read mode: file must exist
         node, err = root_fs:traverse(actualPath)
         if not node then
             return nil, err or "file not found"
         end
 
         if node.type ~= "file" then
             return nil, "not a file"
         end
 
         -- Handle pseudo files with arguments
         if node.isPseudo and args then
             -- Store args for the file handle to use
             node._tempArgs = args
         end
     elseif mode:sub(1, 1) == "w" then
         -- Write mode: create or truncate file
         node, err = root_fs:traverse(filepath)
 
         if node then
             if node.type ~= "file" then
                 return nil, "not a file"
             end
             -- Truncate existing file
             node.contents = ""
         else
             -- Create new file
             -- Parse directory path
             local dir_path = filepath:match("^(.+)/[^/]+$")
             local filename = filepath:match("([^/]+)$")
 
             local parent_dir
             if dir_path then
                 parent_dir, err = root_fs:traverse(dir_path)
                 if not parent_dir then
                     return nil, "directory not found: " .. (dir_path or "")
                 end
             else
                 parent_dir = root_fs
             end
 
             if parent_dir.type ~= "directory" then
                 return nil, "parent is not a directory"
             end
 
             node = parent_dir:newFile(filename, "")
         end
     elseif mode:sub(1, 1) == "a" then
         -- Append mode: create if doesn't exist
         node, err = root_fs:traverse(filepath)
 
         if node then
             if node.type ~= "file" then
                 return nil, "not a file"
             end
         else
             -- Create new file
             local dir_path = filepath:match("^(.+)/[^/]+$")
             local filename = filepath:match("([^/]+)$")
 
             local parent_dir
             if dir_path then
                 parent_dir, err = root_fs:traverse(dir_path)
                 if not parent_dir then
                     return nil, "directory not found: " .. (dir_path or "")
                 end
             else
                 parent_dir = root_fs
             end
 
             if parent_dir.type ~= "directory" then
                 return nil, "parent is not a directory"
             end
 
             node = parent_dir:newFile(filename, "")
         end
     end
 
     -- Create file handle
     local handle = {
         node = node,
         mode = mode,
         position = (mode:sub(1, 1) == "a") and #(node.contents or "") or 0
     }
     setmetatable(handle, FileHandle)
 
     return handle
 end
 
 -- Global io table
 _G.io = _G.io or {}
 _G.io.open = io_open
 
 -- Helper: read entire file (shortcut)
 function _G.readFile(filepath)
     local file, err = io.open(filepath, "r")
     if not file then
         return nil, err
     end
 
     local content = file:read("*a")
     file:close()
 
     return content
 end
 
 -- Helper: write entire file (shortcut)
 function _G.writeFile(filepath, content)
     local file, err = io.open(filepath, "w")
     if not file then
         return nil, err
     end
 
     file:write(content)
     file:close()
 
     return true
 end