@ifunny/ifunny-api-types 1.2.0 → 1.2.2

package/.devenv/bootstrap/bootstrapLib.nix

@@ -489,9 +489,16 @@ rec {
         options: config:
         lib.concatMapAttrs (
           name: option:
-          if lib.isOption option then
+          # Skip invisible options (e.g. renamed aliases from
+          # `mkRenamedOptionModule`, which forward reads to their target and
+          # trigger deprecation warnings).
+          if lib.isOption option && (option.visible or true) == false then
+            { }
+          else if lib.isOption option then
             let
               typeName = option.type.name or "";
+              elemType = option.type.nestedTypes.elemType or null;
+              elemTypeName = elemType.name or "";
             in
             if
               builtins.elem typeName [
@@ -502,6 +509,19 @@ rec {
               {
                 ${name} = config.${name};
               }
+            # Recurse into `attrsOf submodule` options (e.g. `machines`) so
+            # that output-typed sub-options inside each submodule entry become
+            # build targets under `build.<name>.<entry>.<sub>`. Without this,
+            # a `mkOption { type = attrsOf submodule; }` is opaque to the
+            # walker and none of its nested outputs are ever collected.
+            else if typeName == "attrsOf" && elemTypeName == "submodule" then
+              let
+                subOptions = elemType.getSubOptions [ ];
+                entries = config.${name} or { };
+                perEntry = lib.mapAttrs (_entryName: entryConfig: build subOptions entryConfig) entries;
+                filtered = lib.filterAttrs (_: v: v != { }) perEntry;
+              in
+              if filtered != { } then { ${name} = filtered; } else { }
             else
               { }
           else if builtins.isAttrs option && !lib.isDerivation option then

package/.devenv/bootstrap/lock-sources.nix

@@ -0,0 +1,123 @@
+# Source resolution shared by YAML discovery and full flake evaluation.
+{
+  src,
+  lockFile,
+  rootSrc ? {
+    outPath = src;
+  },
+}:
+let
+  sourceInfo =
+    key: node:
+    if key == lockFile.root then
+      rootSrc
+    # Path inputs pointing to project root (path = ".") should use rootSrc
+    # to avoid fetchTree hashing the entire project directory
+    else if node.locked.type or null == "path" && node.locked.path or null == "." then
+      rootSrc
+    else
+      let
+        locked = node.locked;
+        isRelativePath =
+          p: p != null && (builtins.substring 0 2 p == "./" || builtins.substring 0 3 p == "../");
+        # Resolve relative paths against src
+        resolvedLocked =
+          locked
+          // (
+            if locked.type or null == "path" && isRelativePath (locked.path or null) then
+              { path = toString src + "/${locked.path}"; }
+            else
+              { }
+          )
+          // (
+            if locked.type or null == "git" && isRelativePath (locked.url or null) then
+              { url = toString src + "/${locked.url}"; }
+            else
+              { }
+          );
+
+        # Local path inputs without a pinned narHash resolve to the live
+        # filesystem path instead of a fetchTree store copy. The lock file
+        # never carries a narHash for them (Nix strips volatile attributes
+        # from local inputs), so a store copy would hide edits from the
+        # eval cache: nothing in the cache key changes when the directory
+        # content changes. Evaluating from the live path makes the eval
+        # cache track every file that is read, so edits invalidate it.
+        isLivePath =
+          locked.type or null == "path"
+          && !(locked ? narHash)
+          && builtins.substring 0 1 (resolvedLocked.path or "") == "/";
+
+        sourceAttrs = node.info or { } // removeAttrs resolvedLocked [ "dir" ];
+        # Final fetches trust the lock's metadata and can substitute the
+        # source from a binary cache. Keep ordinary fetches for inputs
+        # whose missing metadata still needs to be supplied by the fetcher.
+        hasLockedMetadata =
+          sourceAttrs ? narHash
+          && (
+            sourceAttrs.type == "file"
+            || (
+              builtins.elem sourceAttrs.type [
+                "git"
+                "github"
+                "gitlab"
+                "sourcehut"
+                "tarball"
+              ]
+              && sourceAttrs ? lastModified
+              && (sourceAttrs.type == "tarball" || sourceAttrs ? rev)
+              && (sourceAttrs.type != "git" || (sourceAttrs.shallow or true) || sourceAttrs ? revCount)
+            )
+          );
+        fetchTree =
+          if hasLockedMetadata then builtins.fetchFinalTree or builtins.fetchTree else builtins.fetchTree;
+        fetchedSource = fetchTree sourceAttrs;
+      in
+      if isLivePath then
+        {
+          # Keep fetchTree's public metadata available to flakes that use
+          # self.narHash or self.lastModified. These inherited values stay
+          # lazy, so the live input is only hashed if metadata is read.
+          inherit (fetchedSource) lastModified lastModifiedDate narHash;
+          outPath = /. + resolvedLocked.path;
+        }
+      else
+        fetchedSource;
+
+  # Resolve a input spec into a node name. An input spec is
+  # either a node name, or a 'follows' path from the root
+  # node.
+  resolveInput =
+    inputSpec: if builtins.isList inputSpec then getInputByPath lockFile.root inputSpec else inputSpec;
+
+  # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
+  # root node, returning the final node.
+  getInputByPath =
+    nodeName: path:
+    if path == [ ] then
+      nodeName
+    else
+      getInputByPath
+        # Since this could be a 'follows' input, call resolveInput.
+        (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
+        (builtins.tail path);
+
+  nodeSource =
+    key:
+    let
+      node = lockFile.nodes.${key};
+    in
+    {
+      repository_root = (sourceInfo key node).outPath;
+      dir = if key == lockFile.root then "" else node.locked.dir or "";
+    };
+in
+{
+  inherit sourceInfo resolveInput nodeSource;
+  nodePath =
+    key:
+    let
+      source = nodeSource key;
+    in
+    source.repository_root + (if source.dir == "" then "" else "/${source.dir}");
+}

package/.devenv/bootstrap/resolve-input-paths.nix

@@ -0,0 +1,34 @@
+{
+  src,
+  names,
+  lockFileJSON,
+  sourceResolver ? import ./lock-sources.nix,
+}:
+let
+  lockFilePath = src + "/devenv.lock";
+  lockFile = builtins.fromJSON lockFileJSON;
+  sources = sourceResolver { inherit src lockFile; };
+  rootInputs = lockFile.nodes.${lockFile.root}.inputs or { };
+in
+if lockFile.version < 5 || lockFile.version > 7 then
+  throw "lock file '${lockFilePath}' has unsupported version ${toString lockFile.version}"
+else
+  builtins.listToAttrs (
+    map (
+      name:
+      if !(builtins.hasAttr name rootInputs) then
+        throw "input '${name}' is missing from ${lockFilePath}"
+      else
+        {
+          inherit name;
+          value =
+            let
+              source = sources.nodeSource (sources.resolveInput rootInputs.${name});
+            in
+            {
+              repository_root = toString source.repository_root;
+              inherit (source) dir;
+            };
+        }
+    ) names
+  )

package/.devenv/bootstrap/resolve-lock.nix

@@ -43,88 +43,14 @@ let
     in
     "${toString y'}${pad (toString m)}${pad (toString d)}${pad (toString hours)}${pad (toString minutes)}${pad (toString seconds)}";
 
+  sources = import ./lock-sources.nix { inherit src lockFile rootSrc; };
+
   allNodes = builtins.mapAttrs (
     key: node:
     let
-      sourceInfo =
-        if key == lockFile.root then
-          rootSrc
-        # Path inputs pointing to project root (path = ".") should use rootSrc
-        # to avoid fetchTree hashing the entire project directory
-        else if node.locked.type or null == "path" && node.locked.path or null == "." then
-          rootSrc
-        else
-          let
-            locked = node.locked;
-            isRelativePath =
-              p: p != null && (builtins.substring 0 2 p == "./" || builtins.substring 0 3 p == "../");
-            # Resolve relative paths against src
-            resolvedLocked =
-              locked
-              // (
-                if locked.type or null == "path" && isRelativePath (locked.path or null) then
-                  { path = toString src + "/${locked.path}"; }
-                else
-                  { }
-              )
-              // (
-                if locked.type or null == "git" && isRelativePath (locked.url or null) then
-                  { url = toString src + "/${locked.url}"; }
-                else
-                  { }
-              );
-
-            # Local path inputs without a pinned narHash resolve to the live
-            # filesystem path instead of a fetchTree store copy. The lock file
-            # never carries a narHash for them (Nix strips volatile attributes
-            # from local inputs), so a store copy would hide edits from the
-            # eval cache: nothing in the cache key changes when the directory
-            # content changes. Evaluating from the live path makes the eval
-            # cache track every file that is read, so edits invalidate it.
-            isLivePath =
-              locked.type or null == "path"
-              && !(locked ? narHash)
-              && builtins.substring 0 1 (resolvedLocked.path or "") == "/";
-
-            fetchedSource = builtins.fetchTree (node.info or { } // removeAttrs resolvedLocked [ "dir" ]);
-          in
-          if isLivePath then
-            {
-              # Keep fetchTree's public metadata available to flakes that use
-              # self.narHash or self.lastModified. These inherited values stay
-              # lazy, so the live input is only hashed if metadata is read.
-              inherit (fetchedSource) lastModified lastModifiedDate narHash;
-              outPath = /. + resolvedLocked.path;
-            }
-          else
-            fetchedSource;
-
-      subdir = if key == lockFile.root then "" else node.locked.dir or "";
-
-      # Concatenate on sourceInfo.outPath directly (not the attrset, whose
-      # string coercion would turn live path values into context-free
-      # strings) so live path inputs keep a path-typed outPath. Path values
-      # copy to the store on string interpolation, which keeps derivation
-      # references to input files working.
-      outPath = sourceInfo.outPath + ((if subdir == "" then "" else "/") + subdir);
-
-      # Resolve a input spec into a node name. An input spec is
-      # either a node name, or a 'follows' path from the root
-      # node.
-      resolveInput =
-        inputSpec: if builtins.isList inputSpec then getInputByPath lockFile.root inputSpec else inputSpec;
-
-      # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
-      # root node, returning the final node.
-      getInputByPath =
-        nodeName: path:
-        if path == [ ] then
-          nodeName
-        else
-          getInputByPath
-            # Since this could be a 'follows' input, call resolveInput.
-            (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
-            (builtins.tail path);
+      sourceInfo = sources.sourceInfo key node;
+      outPath = sources.nodePath key;
+      inherit (sources) resolveInput;
 
       inputs = builtins.mapAttrs (inputName: inputSpec: allNodes.${resolveInput inputSpec}) (
         node.inputs or { }

package/.devenv/changelog-cache.json

@@ -1,9 +1,13 @@
 {
   "shown_hashes": [
-    "053d92e6228a113aaf85e8f544485eb3f64cc8b4ed6ec52abf21847cbc637b53",
-    "97c8d967408d5e8dbaefb984ff368930aa96af9c3655e6d867154992052f5881",
     "c40a016aca4dd81dcdca91ff004d81492328aa4b5c49912d6b83a945c2feff84",
+    "8839032c01350edeedfc4b3a2a745aa492e52c72f312cea40001db7ddd425a0c",
     "e6825d4a5422d776d0eb3054f874bf73d8e32e9259f2d7be3a633cbce6bccdcd",
-    "5a589290b7df7d37070a19af3adb407d66ebcfeaa9cd6b628ea0c1998d7a6cde"
+    "97c8d967408d5e8dbaefb984ff368930aa96af9c3655e6d867154992052f5881",
+    "c676d28e6e161c0158c0f01f391da5d29a407d0a84fca705572b092ef839ee04",
+    "053d92e6228a113aaf85e8f544485eb3f64cc8b4ed6ec52abf21847cbc637b53",
+    "7e644d0388477d89d10f791e1509430c333b9585ad4215f913f292e10e248575",
+    "5a589290b7df7d37070a19af3adb407d66ebcfeaa9cd6b628ea0c1998d7a6cde",
+    "b81b889e24497f586305db7e9d9f0a4cfc0f802a8ef0a4c72b367ae6a70e5047"
   ]
 }

package/.devenv/devenv.fish

@@ -1,14 +1,12 @@
 # devenv fish init
 
-# If this shell was spawned by the devenv hook (marked by `_DEVENV_HOOK_DIR`),
-# `exit` when the user `cd`s outside the project so the parent shell can
-# follow. Handled here (devenv's own init file, not the user's hook.fish) so
-# it works regardless of whether the user's config.fish re-sources the hook
-# for this non-login shell. Erase the marker as soon as it is read so it
-# cannot leak into further descendants (a new tmux/zellij pane, a
-# manually started nested shell, ...) which would otherwise wrongly conclude
-# they too are hook-spawned.
-if set -q _DEVENV_HOOK_DIR
+# If this shell was spawned by the devenv hook, `exit` when the user `cd`s
+# outside the project so the parent shell can follow. The user's config.fish
+# may already have moved `_DEVENV_HOOK_DIR` to the non-exported
+# `_devenv_hook_dir` before this init file runs. Accept either marker so the
+# exit happens on PWD change, before prompt handlers can query the terminal.
+# Erase the exported marker so it cannot leak into further descendants.
+if set -q _DEVENV_HOOK_DIR; or set -q _devenv_hook_dir
     set -e _DEVENV_HOOK_DIR
     function _devenv_shell_exit_on_cd_out --on-variable PWD
         switch $PWD
@@ -44,7 +42,7 @@ end
 
 function __devenv_reload_apply
     # Source new environment if a reload is pending
-    if test -f "/tmp/devenv-reload-528741.sh"
+    if test -f "/tmp/devenv-reload-283714.sh"
         # Shell out to bash to handle the env diff (bash syntax).
         # The bash subprocess inherits our current environment, reverses
         # the previous diff, sources the new devenv env, computes a new
@@ -173,6 +171,8 @@ __devenv_apply_reverse_diff() {
 }
 
 
+
+
 # Reverse previous diff
 __devenv_apply_reverse_diff
 
@@ -190,15 +190,15 @@ else
 fi
 
 # Source new devenv environment
-source "/tmp/devenv-reload-528741.sh" >"$_devenv_reload_out" 2>"$_devenv_reload_out"
-rm -f "/tmp/devenv-reload-528741.sh"
+source "/tmp/devenv-reload-283714.sh" >"$_devenv_reload_out" 2>"$_devenv_reload_out"
+rm -f "/tmp/devenv-reload-283714.sh"
 unset _devenv_reload_out
 
 # Compute new diff
 __devenv_compute_diff "$_before"
 rm -f "$_before"
 
-# Output current environment for the calling shell to parse
+# Output environment data for the calling shell to apply
 export -p
         ' 2>/dev/null)
 

package/.devenv/input-paths.txt

@@ -1,10 +1,8 @@
 /home/shift/.config/nixpkgs/overlays
 /home/shift/.config/nixpkgs/overlays.nix
-/media/Code/@Open-iFunny/ifunny-api-types/.devenv/bootstrap/bootstrapLib.nix
-/media/Code/@Open-iFunny/ifunny-api-types/.devenv/bootstrap/default.nix
-/media/Code/@Open-iFunny/ifunny-api-types/.devenv/bootstrap/resolve-lock.nix
 /media/Code/@Open-iFunny/ifunny-api-types/.env
 /media/Code/@Open-iFunny/ifunny-api-types/devenv.local.nix
 /media/Code/@Open-iFunny/ifunny-api-types/devenv.lock
 /media/Code/@Open-iFunny/ifunny-api-types/devenv.nix
-/media/Code/@Open-iFunny/ifunny-api-types/devenv.yaml
+/media/Code/@Open-iFunny/ifunny-api-types/devenv.yaml
+/run/user/1000/devenv-02bb315/processes/native-manager.pid