cleanup

5 files changed, 1047 insertions, 0 deletions

diff --git a/aoc2023/build/packages/simplifile/src/simplifile.app.src b/aoc2023/build/packages/simplifile/src/simplifile.app.src
new file mode 100644
index 0000000..5b9d6ef
--- /dev/null
+++ b/aoc2023/build/packages/simplifile/src/simplifile.app.src
@@ -0,0 +1,8 @@
+{application, simplifile, [
+    {vsn, "1.0.0"},
+    {applications, [gleam_stdlib,
+                    gleeunit]},
+    {description, "Basic file operations that work on all targets"},
+    {modules, [simplifile]},
+    {registered, []}
+]}.
diff --git a/aoc2023/build/packages/simplifile/src/simplifile.erl b/aoc2023/build/packages/simplifile/src/simplifile.erl
new file mode 100644
index 0000000..0d3818c
--- /dev/null
+++ b/aoc2023/build/packages/simplifile/src/simplifile.erl
@@ -0,0 +1,287 @@
+-module(simplifile).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).
+
+-export([read/1, write/2, delete/1, delete_all/1, append/2, read_bits/1, write_bits/2, append_bits/2, is_directory/1, create_directory/1, read_directory/1, is_file/1, create_file/1, get_files/1, create_directory_all/1, copy_directory/2, rename_directory/2, copy_file/2, rename_file/2]).
+-export_type([file_error/0]).
+
+-type file_error() :: eacces |
+    eagain |
+    ebadf |
+    ebadmsg |
+    ebusy |
+    edeadlk |
+    edeadlock |
+    edquot |
+    eexist |
+    efault |
+    efbig |
+    eftype |
+    eintr |
+    einval |
+    eio |
+    eisdir |
+    eloop |
+    emfile |
+    emlink |
+    emultihop |
+    enametoolong |
+    enfile |
+    enobufs |
+    enodev |
+    enolck |
+    enolink |
+    enoent |
+    enomem |
+    enospc |
+    enosr |
+    enostr |
+    enosys |
+    enotblk |
+    enotdir |
+    enotsup |
+    enxio |
+    eopnotsupp |
+    eoverflow |
+    eperm |
+    epipe |
+    erange |
+    erofs |
+    espipe |
+    esrch |
+    estale |
+    etxtbsy |
+    exdev |
+    not_utf8 |
+    unknown.
+
+-spec do_append(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+do_append(Content, Filepath) ->
+    _pipe = Content,
+    _pipe@1 = gleam_stdlib:identity(_pipe),
+    simplifile_erl:append_file(_pipe@1, Filepath).
+
+-spec do_write(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+do_write(Content, Filepath) ->
+    _pipe = Content,
+    _pipe@1 = gleam_stdlib:identity(_pipe),
+    simplifile_erl:write_file(_pipe@1, Filepath).
+
+-spec do_read(binary()) -> {ok, binary()} | {error, file_error()}.
+do_read(Filepath) ->
+    case simplifile_erl:read_file(Filepath) of
+        {ok, Bits} ->
+            case gleam@bit_array:to_string(Bits) of
+                {ok, Str} ->
+                    {ok, Str};
+
+                _ ->
+                    {error, not_utf8}
+            end;
+
+        {error, E} ->
+            {error, E}
+    end.
+
+-spec cast_error({ok, FIL} | {error, file_error()}) -> {ok, FIL} |
+    {error, file_error()}.
+cast_error(Input) ->
+    Input.
+
+-spec read(binary()) -> {ok, binary()} | {error, file_error()}.
+read(Filepath) ->
+    _pipe = do_read(Filepath),
+    cast_error(_pipe).
+
+-spec write(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+write(Filepath, Contents) ->
+    _pipe = do_write(Contents, Filepath),
+    cast_error(_pipe).
+
+-spec delete(binary()) -> {ok, nil} | {error, file_error()}.
+delete(Path) ->
+    _pipe = simplifile_erl:recursive_delete(Path),
+    cast_error(_pipe).
+
+-spec delete_all(list(binary())) -> {ok, nil} | {error, file_error()}.
+delete_all(Paths) ->
+    case Paths of
+        [] ->
+            {ok, nil};
+
+        [Path | Rest] ->
+            case delete(Path) of
+                {ok, nil} ->
+                    delete_all(Rest);
+
+                {error, enoent} ->
+                    delete_all(Rest);
+
+                E ->
+                    E
+            end
+    end.
+
+-spec append(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+append(Filepath, Contents) ->
+    _pipe = do_append(Contents, Filepath),
+    cast_error(_pipe).
+
+-spec read_bits(binary()) -> {ok, bitstring()} | {error, file_error()}.
+read_bits(Filepath) ->
+    _pipe = simplifile_erl:read_file(Filepath),
+    cast_error(_pipe).
+
+-spec write_bits(binary(), bitstring()) -> {ok, nil} | {error, file_error()}.
+write_bits(Filepath, Bits) ->
+    _pipe = simplifile_erl:write_file(Bits, Filepath),
+    cast_error(_pipe).
+
+-spec append_bits(binary(), bitstring()) -> {ok, nil} | {error, file_error()}.
+append_bits(Filepath, Bits) ->
+    _pipe = simplifile_erl:append_file(Bits, Filepath),
+    cast_error(_pipe).
+
+-spec is_directory(binary()) -> boolean().
+is_directory(Filepath) ->
+    filelib:is_dir(Filepath).
+
+-spec create_directory(binary()) -> {ok, nil} | {error, file_error()}.
+create_directory(Filepath) ->
+    _pipe = simplifile_erl:make_directory(Filepath),
+    cast_error(_pipe).
+
+-spec read_directory(binary()) -> {ok, list(binary())} | {error, file_error()}.
+read_directory(Path) ->
+    _pipe = simplifile_erl:list_directory(Path),
+    cast_error(_pipe).
+
+-spec is_file(binary()) -> boolean().
+is_file(Filepath) ->
+    simplifile_erl:is_file(Filepath).
+
+-spec create_file(binary()) -> {ok, nil} | {error, file_error()}.
+create_file(Filepath) ->
+    case begin
+        _pipe = Filepath,
+        is_file(_pipe)
+    end
+    orelse begin
+        _pipe@1 = Filepath,
+        is_directory(_pipe@1)
+    end of
+        true ->
+            {error, eexist};
+
+        false ->
+            write_bits(Filepath, <<>>)
+    end.
+
+-spec do_copy_directory(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+do_copy_directory(Src, Dest) ->
+    gleam@result:'try'(
+        read_directory(Src),
+        fun(Segments) ->
+            _pipe = Segments,
+            gleam@list:each(
+                _pipe,
+                fun(Segment) ->
+                    Src_path = <<<<Src/binary, "/"/utf8>>/binary,
+                        Segment/binary>>,
+                    Dest_path = <<<<Dest/binary, "/"/utf8>>/binary,
+                        Segment/binary>>,
+                    case {is_file(Src_path), is_directory(Src_path)} of
+                        {true, false} ->
+                            gleam@result:'try'(
+                                read_bits(Src_path),
+                                fun(Content) -> _pipe@1 = Content,
+                                    write_bits(Dest_path, _pipe@1) end
+                            );
+
+                        {false, true} ->
+                            gleam@result:'try'(
+                                create_directory(Dest_path),
+                                fun(_) ->
+                                    do_copy_directory(Src_path, Dest_path)
+                                end
+                            );
+
+                        {_, _} ->
+                            erlang:error(#{gleam_error => panic,
+                                    message => <<"unreachable"/utf8>>,
+                                    module => <<"simplifile"/utf8>>,
+                                    function => <<"do_copy_directory"/utf8>>,
+                                    line => 341})
+                    end
+                end
+            ),
+            {ok, nil}
+        end
+    ).
+
+-spec get_files(binary()) -> {ok, list(binary())} | {error, file_error()}.
+get_files(Directory) ->
+    gleam@result:'try'(
+        read_directory(Directory),
+        fun(Contents) ->
+            Paths = gleam@list:map(
+                Contents,
+                fun(Segment) ->
+                    <<<<Directory/binary, "/"/utf8>>/binary, Segment/binary>>
+                end
+            ),
+            Files = gleam@list:filter(Paths, fun is_file/1),
+            case gleam@list:filter(Paths, fun is_directory/1) of
+                [] ->
+                    {ok, Files};
+
+                Directories ->
+                    gleam@result:'try'(
+                        gleam@list:try_map(Directories, fun get_files/1),
+                        fun(Nested_files) ->
+                            {ok,
+                                gleam@list:append(
+                                    Files,
+                                    gleam@list:flatten(Nested_files)
+                                )}
+                        end
+                    )
+            end
+        end
+    ).
+
+-spec create_directory_all(binary()) -> {ok, nil} | {error, file_error()}.
+create_directory_all(Dirpath) ->
+    Path = case begin
+        _pipe = Dirpath,
+        gleam@string:ends_with(_pipe, <<"/"/utf8>>)
+    end of
+        true ->
+            Dirpath;
+
+        false ->
+            <<Dirpath/binary, "/"/utf8>>
+    end,
+    _pipe@1 = simplifile_erl:create_dir_all(Path),
+    cast_error(_pipe@1).
+
+-spec copy_directory(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+copy_directory(Src, Dest) ->
+    gleam@result:'try'(
+        create_directory_all(Dest),
+        fun(_) -> do_copy_directory(Src, Dest) end
+    ).
+
+-spec rename_directory(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+rename_directory(Src, Dest) ->
+    gleam@result:'try'(copy_directory(Src, Dest), fun(_) -> delete(Src) end).
+
+-spec copy_file(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+copy_file(Src, Dest) ->
+    _pipe = file:copy(Src, Dest),
+    _pipe@1 = gleam@result:replace(_pipe, nil),
+    cast_error(_pipe@1).
+
+-spec rename_file(binary(), binary()) -> {ok, nil} | {error, file_error()}.
+rename_file(Src, Dest) ->
+    _pipe = simplifile_erl:rename_file(Src, Dest),
+    cast_error(_pipe).
diff --git a/aoc2023/build/packages/simplifile/src/simplifile.gleam b/aoc2023/build/packages/simplifile/src/simplifile.gleam
new file mode 100644
index 0000000..eff0306
--- /dev/null
+++ b/aoc2023/build/packages/simplifile/src/simplifile.gleam
@@ -0,0 +1,580 @@
+import gleam/bit_array
+import gleam/string
+import gleam/result
+import gleam/list
+
+/// This type represents all of the reasons for why a file system operation could fail.
+///
+/// Most of these reasons are POSIX errors, which come from the operating system
+/// and start with E. Others have been added to represent other issues that may
+/// arise specific to this library.
+///
+pub type FileError {
+  /// Permission denied.
+  Eacces
+  /// Resource temporarily unavailable.
+  Eagain
+  /// Bad file number
+  Ebadf
+  /// Bad message.
+  Ebadmsg
+  /// File busy.
+  Ebusy
+  /// Resource deadlock avoided.
+  Edeadlk
+  /// On most architectures, same as `Edeadlk`. On some architectures, it
+  /// means "File locking deadlock error."
+  Edeadlock
+  /// Disk quota exceeded.
+  Edquot
+  /// File already exists.
+  Eexist
+  /// Bad address in system call argument.
+  Efault
+  /// File too large.
+  Efbig
+  /// Inappropriate file type or format. Usually caused by trying to set the
+  /// "sticky bit" on a regular file (not a directory).
+  Eftype
+  /// Interrupted system call.
+  Eintr
+  /// Invalid argument.
+  Einval
+  /// I/O error.
+  Eio
+  /// Illegal operation on a directory.
+  Eisdir
+  /// Too many levels of symbolic links.
+  Eloop
+  /// Too many open files.
+  Emfile
+  /// Too many links.
+  Emlink
+  /// Multihop attempted.
+  Emultihop
+  /// Filename too long
+  Enametoolong
+  /// File table overflow
+  Enfile
+  /// No buffer space available.
+  Enobufs
+  /// No such device.
+  Enodev
+  /// No locks available.
+  Enolck
+  /// Link has been severed.
+  Enolink
+  /// No such file or directory.
+  Enoent
+  /// Not enough memory.
+  Enomem
+  /// No space left on device.
+  Enospc
+  /// No STREAM resources.
+  Enosr
+  /// Not a STREAM.
+  Enostr
+  /// Function not implemented.
+  Enosys
+  /// Block device required.
+  Enotblk
+  /// Not a directory.
+  Enotdir
+  /// Operation not supported.
+  Enotsup
+  /// No such device or address.
+  Enxio
+  /// Operation not supported on socket.
+  Eopnotsupp
+  /// Value too large to be stored in data type.
+  Eoverflow
+  /// Not owner.
+  Eperm
+  /// Broken pipe.
+  Epipe
+  /// Result too large.
+  Erange
+  /// Read-only file system.
+  Erofs
+  /// Invalid seek.
+  Espipe
+  /// No such process.
+  Esrch
+  /// Stale remote file handle.
+  Estale
+  /// Text file busy.
+  Etxtbsy
+  /// Cross-domain link.
+  Exdev
+  /// File was requested to be read as UTF-8, but is not UTF-8 encoded.
+  NotUtf8
+  /// Any error not accounted for by this type
+  Unknown
+}
+
+/// Read a files contents as a string
+/// ## Example
+/// ```gleam
+/// let assert Ok(records) = read(from: "./users.csv")
+/// ```
+///
+pub fn read(from filepath: String) -> Result(String, FileError) {
+  do_read(filepath)
+  |> cast_error
+}
+
+/// Write a string to a file at the given path
+/// ## Example
+/// ```gleam
+/// let assert Ok(Nil) = write("Hello, World!", to: "./hello_world.txt")
+/// ```
+///
+pub fn write(
+  to filepath: String,
+  contents contents: String,
+) -> Result(Nil, FileError) {
+  do_write(contents, to: filepath)
+  |> cast_error
+}
+
+/// Delete a file or directory at a given path. Performs a recursive
+/// delete on a directory.
+/// Throws an error if the path does not exist.
+/// ## Example
+/// ```gleam
+/// let assert Ok(Nil) = delete(file_at: "./delete_me.txt")
+/// ```
+///
+pub fn delete(file_or_dir_at path: String) -> Result(Nil, FileError) {
+  do_delete(path)
+  |> cast_error
+}
+
+/// Delete all files/directories specified in a list of paths.
+/// Recursively deletes provided directories.
+/// Does not return an error if one or more of the provided paths 
+/// do not exist. 
+/// 
+pub fn delete_all(paths paths: List(String)) -> Result(Nil, FileError) {
+  case paths {
+    [] -> Ok(Nil)
+    [path, ..rest] -> {
+      case delete(path) {
+        Ok(Nil) | Error(Enoent) -> delete_all(rest)
+        e -> e
+      }
+    }
+  }
+}
+
+/// Append a string to the contents of a file at the given path
+/// ## Example
+/// ```gleam
+/// let assert Ok(Nil) = append("more text", to: "./needs_more_text.txt")
+/// ```
+///
+pub fn append(
+  to filepath: String,
+  contents contents: String,
+) -> Result(Nil, FileError) {
+  do_append(contents, to: filepath)
+  |> cast_error
+}
+
+/// Read a files contents as a bitstring
+/// ## Example
+/// ```gleam
+/// let assert Ok(records) = read_bits(from: "./users.csv")
+/// ```
+///
+pub fn read_bits(from filepath: String) -> Result(BitArray, FileError) {
+  do_read_bits(filepath)
+  |> cast_error
+}
+
+/// Write a bitstring to a file at the given path
+/// ## Example
+/// ```gleam
+/// let assert Ok(Nil) = write_bits(<<"Hello, World!":utf8>>, to: "./hello_world.txt")
+/// ```
+///
+pub fn write_bits(
+  to filepath: String,
+  bits bits: BitArray,
+) -> Result(Nil, FileError) {
+  do_write_bits(bits, filepath)
+  |> cast_error
+}
+
+/// Append a bitstring to the contents of a file at the given path
+/// ## Example
+/// ```gleam
+/// let assert Ok(Nil) = append_bits(<<"more text":utf8>>, to: "./needs_more_text.txt")
+/// ```
+///
+pub fn append_bits(
+  to filepath: String,
+  bits bits: BitArray,
+) -> Result(Nil, FileError) {
+  do_append_bits(bits, filepath)
+  |> cast_error
+}
+
+/// Checks if the provided filepath is a directory
+/// ## Example
+/// ```gleam
+/// let assert True = is_directory("./test")
+/// ```
+pub fn is_directory(filepath: String) -> Bool {
+  do_is_directory(filepath)
+}
+
+/// Create a directory at the provided filepath. Returns an error if
+/// the directory already exists.
+///
+/// ## Example
+/// ```gleam
+/// create_directory("./test")
+/// ```
+pub fn create_directory(filepath: String) -> Result(Nil, FileError) {
+  do_make_directory(filepath)
+  |> cast_error
+}
+
+/// Lists the contents of a directory.
+/// The list contains directory and file names, and is not recursive.
+/// 
+/// ## Example
+/// ```gleam
+/// let assert Ok(files_and_folders) = read_directory(at: "./Folder1")
+/// ```
+/// 
+pub fn read_directory(at path: String) -> Result(List(String), FileError) {
+  do_read_directory(path)
+  |> cast_error
+}
+
+/// Returns `True` if there is a file at the given path, false otherwise.
+/// 
+pub fn is_file(filepath: String) -> Bool {
+  do_is_file(filepath)
+}
+
+/// Creates an empty file at the given filepath. Returns an `Error(Eexist)`
+/// if the file already exists.
+/// 
+pub fn create_file(at filepath: String) -> Result(Nil, FileError) {
+  case
+    filepath
+    |> is_file || filepath
+    |> is_directory
+  {
+    True -> Error(Eexist)
+    False -> write_bits(<<>>, to: filepath)
+  }
+}
+
+/// Recursively creates necessary directories for a given directory
+/// path. Note that if you pass a path that "looks like" a file, i.e.
+/// `./a/b.txt`, a folder named `b.txt` will be created, so be sure
+/// to pass only the path to the required directory.
+pub fn create_directory_all(dirpath: String) -> Result(Nil, FileError) {
+  let path = case
+    dirpath
+    |> string.ends_with("/")
+  {
+    True -> dirpath
+    False -> dirpath <> "/"
+  }
+  do_create_dir_all(path)
+  |> cast_error
+}
+
+/// Copy a file at a given path to another path.
+/// Note: destination should include the filename, not just the directory
+pub fn copy_file(at src: String, to dest: String) -> Result(Nil, FileError) {
+  do_copy_file(src, dest)
+  |> result.replace(Nil)
+  |> cast_error
+}
+
+/// Rename a file at a given path to another path.
+/// Note: destination should include the filename, not just the directory
+pub fn rename_file(at src: String, to dest: String) -> Result(Nil, FileError) {
+  do_rename_file(src, dest)
+  |> cast_error
+}
+
+/// Copy a directory recursively
+pub fn copy_directory(at src: String, to dest: String) -> Result(Nil, FileError) {
+  // Erlang does not provide a built in `copy_dir` function, 
+  // and Deno doesn't support Node's `fs.cpSync`, so we'll just roll 
+  // our own for now.
+  use _ <- result.try(create_directory_all(dest))
+  do_copy_directory(src, dest)
+}
+
+fn do_copy_directory(src: String, dest: String) -> Result(Nil, FileError) {
+  // Iterate over the segments of the file
+  use segments <- result.try(read_directory(src))
+  segments
+  |> list.each(fn(segment) {
+    let src_path = src <> "/" <> segment
+    let dest_path = dest <> "/" <> segment
+
+    case is_file(src_path), is_directory(src_path) {
+      True, False -> {
+        // For a file, create the file in the new directory
+        use content <- result.try(read_bits(src_path))
+        content
+        |> write_bits(to: dest_path)
+      }
+      False, True -> {
+        // Create the target directory and recurs
+        use _ <- result.try(create_directory(dest_path))
+        do_copy_directory(src_path, dest_path)
+      }
+      _, _ -> {
+        // This should be unreachable. The src_path can't be both a file
+        // and a directory, and it's definitely one of the two because it's
+        // coming from list_contents
+        panic as "unreachable"
+      }
+    }
+  })
+  Ok(Nil)
+}
+
+/// Copy a directory recursively and then delete the old one.
+pub fn rename_directory(
+  at src: String,
+  to dest: String,
+) -> Result(Nil, FileError) {
+  use _ <- result.try(copy_directory(src, dest))
+  delete(src)
+}
+
+/// Returns a list of filepaths for every file in the directory, including nested
+/// files.
+/// 
+pub fn get_files(in directory: String) -> Result(List(String), FileError) {
+  use contents <- result.try(read_directory(directory))
+  let paths = list.map(contents, fn(segment) { directory <> "/" <> segment })
+  let files = list.filter(paths, is_file)
+  case list.filter(paths, is_directory) {
+    [] -> Ok(files)
+    directories -> {
+      use nested_files <- result.try(list.try_map(directories, get_files))
+      Ok(list.append(files, list.flatten(nested_files)))
+    }
+  }
+}
+
+@target(javascript)
+fn do_read(from filepath: String) -> Result(String, String) {
+  case do_read_bits(filepath) {
+    Ok(bits) -> {
+      case bit_array.to_string(bits) {
+        Ok(str) -> Ok(str)
+        _ -> Error("NOTUTF8")
+      }
+    }
+    Error(e) -> Error(e)
+  }
+}
+
+@target(javascript)
+fn do_write(content: String, to filepath: String) -> Result(Nil, String) {
+  content
+  |> bit_array.from_string
+  |> do_write_bits(to: filepath)
+}
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "deleteFileOrDirRecursive")
+fn do_delete(file_or_dir_at: String) -> Result(Nil, String)
+
+@target(javascript)
+fn do_append(content: String, to filepath: String) -> Result(Nil, String) {
+  content
+  |> bit_array.from_string
+  |> do_append_bits(to: filepath)
+}
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "readBits")
+fn do_read_bits(from: String) -> Result(BitArray, String)
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "writeBits")
+fn do_write_bits(content: BitArray, to filepath: String) -> Result(Nil, String)
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "appendBits")
+fn do_append_bits(content: BitArray, to filepath: String) -> Result(Nil, String)
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "isDirectory")
+fn do_is_directory(filepath: String) -> Bool
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "makeDirectory")
+fn do_make_directory(filepath: String) -> Result(Nil, String)
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "createDirAll")
+fn do_create_dir_all(dirpath: String) -> Result(Nil, String)
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "listContents")
+fn do_read_directory(directory_path: String) -> Result(List(String), String)
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "copyFile")
+fn do_copy_file(at: String, to: String) -> Result(Nil, String)
+
+@target(javascript)
+@external(javascript, "./simplifile_js.mjs", "renameFile")
+fn do_rename_file(at: String, to: String) -> Result(Nil, String)
+
+@target(javascript)
+fn cast_error(input: Result(a, String)) -> Result(a, FileError) {
+  result.map_error(
+    input,
+    fn(e) {
+      case e {
+        "EACCES" -> Eacces
+        "EAGAIN" -> Eagain
+        "EBADF" -> Ebadf
+        "EBADMSG" -> Ebadmsg
+        "EBUSY" -> Ebusy
+        "EDEADLK" -> Edeadlk
+        "EDEADLOCK" -> Edeadlock
+        "EDQUOT" -> Edquot
+        "EEXIST" -> Eexist
+        "EFAULT" -> Efault
+        "EFBIG" -> Efbig
+        "EFTYPE" -> Eftype
+        "EINTR" -> Eintr
+        "EINVAL" -> Einval
+        "EIO" -> Eio
+        "EISDIR" -> Eisdir
+        "ELOOP" -> Eloop
+        "EMFILE" -> Emfile
+        "EMLINK" -> Emlink
+        "EMULTIHOP" -> Emultihop
+        "ENAMETOOLONG" -> Enametoolong
+        "ENFILE" -> Enfile
+        "ENOBUFS" -> Enobufs
+        "ENODEV" -> Enodev
+        "ENOLCK" -> Enolck
+        "ENOLINK" -> Enolink
+        "ENOENT" -> Enoent
+        "ENOMEM" -> Enomem
+        "ENOSPC" -> Enospc
+        "ENOSR" -> Enosr
+        "ENOSTR" -> Enostr
+        "ENOSYS" -> Enosys
+        "ENOBLK" -> Enotblk
+        "ENODIR" -> Enotdir
+        "ENOTSUP" -> Enotsup
+        "ENXIO" -> Enxio
+        "EOPNOTSUPP" -> Eopnotsupp
+        "EOVERFLOW" -> Eoverflow
+        "EPERM" -> Eperm
+        "EPIPE" -> Epipe
+        "ERANGE" -> Erange
+        "EROFS" -> Erofs
+        "ESPIPE" -> Espipe
+        "ESRCH" -> Esrch
+        "ESTALE" -> Estale
+        "ETXTBSY" -> Etxtbsy
+        "EXDEV" -> Exdev
+        "NOTUTF8" -> NotUtf8
+        _ -> Unknown
+      }
+    },
+  )
+}
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "append_file")
+fn do_append_bits(
+  content: BitArray,
+  to filepath: String,
+) -> Result(Nil, FileError)
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "write_file")
+fn do_write_bits(
+  content: BitArray,
+  to filepath: String,
+) -> Result(Nil, FileError)
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "read_file")
+fn do_read_bits(from: String) -> Result(BitArray, FileError)
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "recursive_delete")
+fn do_delete(file_or_dir_at: String) -> Result(Nil, FileError)
+
+@target(erlang)
+fn do_append(content: String, to filepath: String) -> Result(Nil, FileError) {
+  content
+  |> bit_array.from_string
+  |> do_append_bits(filepath)
+}
+
+@target(erlang)
+fn do_write(content: String, to filepath: String) -> Result(Nil, FileError) {
+  content
+  |> bit_array.from_string
+  |> do_write_bits(filepath)
+}
+
+@target(erlang)
+fn do_read(from filepath: String) -> Result(String, FileError) {
+  case do_read_bits(filepath) {
+    Ok(bits) -> {
+      case bit_array.to_string(bits) {
+        Ok(str) -> Ok(str)
+        _ -> Error(NotUtf8)
+      }
+    }
+    Error(e) -> Error(e)
+  }
+}
+
+@target(erlang)
+fn cast_error(input: Result(a, FileError)) -> Result(a, FileError) {
+  input
+}
+
+@target(erlang)
+@external(erlang, "filelib", "is_dir")
+fn do_is_directory(path: String) -> Bool
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "make_directory")
+fn do_make_directory(directory: String) -> Result(Nil, FileError)
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "list_directory")
+fn do_read_directory(directory: String) -> Result(List(String), FileError)
+
+@external(erlang, "simplifile_erl", "is_file")
+@external(javascript, "./simplifile_js.mjs", "isFile")
+fn do_is_file(filepath: String) -> Bool
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "create_dir_all")
+fn do_create_dir_all(dirpath: String) -> Result(Nil, FileError)
+
+@target(erlang)
+@external(erlang, "file", "copy")
+fn do_copy_file(src: String, dest: String) -> Result(Int, FileError)
+
+@target(erlang)
+@external(erlang, "simplifile_erl", "rename_file")
+fn do_rename_file(src: String, dest: String) -> Result(Nil, FileError)
diff --git a/aoc2023/build/packages/simplifile/src/simplifile_erl.erl b/aoc2023/build/packages/simplifile/src/simplifile_erl.erl
new file mode 100644
index 0000000..dac135a
--- /dev/null
+++ b/aoc2023/build/packages/simplifile/src/simplifile_erl.erl
@@ -0,0 +1,70 @@
+-module(simplifile_erl).
+-export([
+    read_file/1,
+    append_file/2, write_file/2, delete_file/1, delete_directory/1, recursive_delete/1,
+    list_directory/1, make_directory/1, is_file/1, create_dir_all/1, rename_file/2
+]).
+
+-define(is_posix_error(Error),
+    Error =:= eacces orelse Error =:= eagain orelse Error =:= ebadf orelse
+    Error =:= ebadmsg orelse Error =:= ebusy orelse Error =:= edeadlk orelse
+    Error =:= edeadlock orelse Error =:= edquot orelse Error =:= eexist orelse
+    Error =:= efault orelse Error =:= efbig orelse Error =:= eftype orelse
+    Error =:= eintr orelse Error =:= einval orelse Error =:= eio orelse
+    Error =:= eisdir orelse Error =:= eloop orelse Error =:= emfile orelse
+    Error =:= emlink orelse Error =:= emultihop orelse Error =:= enametoolong orelse
+    Error =:= enfile orelse Error =:= enobufs orelse Error =:= enodev orelse
+    Error =:= enolck orelse Error =:= enolink orelse Error =:= enoent orelse
+    Error =:= enomem orelse Error =:= enospc orelse Error =:= enosr orelse
+    Error =:= enostr orelse Error =:= enosys orelse Error =:= enotblk orelse
+    Error =:= enotdir orelse Error =:= enotsup orelse Error =:= enxio orelse
+    Error =:= eopnotsupp orelse Error =:= eoverflow orelse Error =:= eperm orelse
+    Error =:= epipe orelse Error =:= erange orelse Error =:= erofs orelse
+    Error =:= espipe orelse Error =:= esrch orelse Error =:= estale orelse
+    Error =:= etxtbsy orelse Error =:= exdev
+).
+
+posix_result(Result) ->
+    case Result of
+        ok -> {ok, nil};
+        {ok, Value} -> {ok, Value};
+        {error, Reason} when ?is_posix_error(Reason) -> {error, Reason}
+    end.
+
+read_file(Filename) ->
+    posix_result(file:read_file(Filename)).
+
+write_file(Contents, Filename) ->
+    posix_result(file:write_file(Filename, Contents)).
+
+append_file(Contents, Filename) ->
+    posix_result(file:write_file(Filename, Contents, [append])).
+
+delete_file(Filename) ->
+    posix_result(file:delete(Filename)).
+
+make_directory(Dir) ->
+    posix_result(file:make_dir(Dir)).
+
+list_directory(Dir) ->
+    case file:list_dir(Dir) of
+        {ok, Filenames} ->
+            {ok, [list_to_binary(Filename) || Filename <- Filenames]};
+        {error, Reason} when ?is_posix_error(Reason) ->
+            {error, Reason}
+    end.
+
+delete_directory(Dir) ->
+    posix_result(file:del_dir(Dir)).
+
+recursive_delete(Dir) ->
+    posix_result(file:del_dir_r(Dir)).
+
+is_file(Filename) ->
+    not (file:read_file_info(Filename) == {error, enoent}) and not filelib: is_dir(Filename).
+
+create_dir_all(Filename) ->
+    posix_result(filelib:ensure_dir(Filename)).
+
+rename_file(Source, Destination) ->
+    posix_result(file:rename(Source, Destination)).
diff --git a/aoc2023/build/packages/simplifile/src/simplifile_js.mjs b/aoc2023/build/packages/simplifile/src/simplifile_js.mjs
new file mode 100644
index 0000000..faf4109
--- /dev/null
+++ b/aoc2023/build/packages/simplifile/src/simplifile_js.mjs
@@ -0,0 +1,102 @@
+import fs from "node:fs"
+import path from "node:path"
+import { BitArray, Ok, Error as GError, toList} from "./gleam.mjs";
+
+export function readBits(filepath) {
+    try {
+        const contents = fs.readFileSync(path.normalize(filepath))
+        return new Ok(new BitArray(new Uint8Array(contents)))
+    } catch(e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+export function writeBits(contents, filepath) {
+    try {
+        fs.writeFileSync(path.normalize(filepath), contents.buffer)
+        return new Ok(undefined)
+    } catch (e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+export function appendBits(contents, filepath) {
+    try {
+        fs.appendFileSync(path.normalize(filepath), contents.buffer)
+        return new Ok(undefined)
+    } catch (e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+function stringifyError(e) {
+    return e.code
+}
+
+export function isFile(filepath) {
+    let fp = path.normalize(filepath)
+    return fs.existsSync(fp) && fs.lstatSync(fp).isFile();
+}
+
+export function isDirectory(filepath) {
+    let fp = path.normalize(filepath)
+    return fs.existsSync(fp) && fs.lstatSync(fp).isDirectory();
+}
+
+export function makeDirectory(filepath) {
+    try {
+        fs.mkdirSync(path.normalize(filepath))
+        return new Ok(undefined)
+    } catch (e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+export function createDirAll(filepath) {
+    try {
+        fs.mkdirSync(filepath, { recursive: true })
+        return new Ok(undefined)
+    } catch (e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+export function deleteFileOrDirRecursive(fileOrDirPath) {
+    try {
+        if (isDirectory(fileOrDirPath)) {
+            fs.rmSync(path.normalize(fileOrDirPath), { recursive: true })
+        } else {
+            fs.unlinkSync(path.normalize(fileOrDirPath))
+        }
+        return new Ok(undefined)
+    } catch (e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+export function listContents(filepath) {
+    try {
+        const stuff = toList(fs.readdirSync(path.normalize(filepath)))
+        return new Ok(stuff)
+    } catch(e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+export function copyFile(srcpath, destpath) {
+    try {
+        fs.copyFileSync(path.normalize(srcpath), path.normalize(destpath))
+        return new Ok(undefined)
+    } catch (e) {
+        return new GError(stringifyError(e))
+    }
+}
+
+export function renameFile(srcpath, destpath) {
+    try {
+        fs.renameSync(path.normalize(srcpath), path.normalize(destpath))
+        return new Ok(undefined)
+    } catch (e) {
+        return new GError(stringifyError(e))
+    }
+}
\ No newline at end of file