commit db08c8d4da028146b4f43c0b21ba007bab9b46f5 · pyrox.dev/nixpkgs

+6 -3

maintainers/maintainer-list.nix

···

       7010
       7010
        
           github = "ethancedwards8";

     

       7011
       7011
        
           githubId = 60861925;

     

       7012
       7012
        
           name = "Ethan Carter Edwards";

     

       7013
       7013
       -
           keys = [ { fingerprint = "0E69 0F46 3457 D812 3387  C978 F93D DAFA 26EF 2458"; } ];

     

       7013
       7013
       +
           keys = [

     

       7014
       7014
       +
             { fingerprint = "0E69 0F46 3457 D812 3387  C978 F93D DAFA 26EF 2458"; }

     

       7015
       7015
       +
             { fingerprint = "2E51 F618 39D1 FA94 7A73  00C2 34C0 4305 D581 DBFE"; }

     

       7016
       7016
       +
           ];

     

       7014
       7017
        
         };

     

       7015
       7018
        
         ethercrow = {

     

       7016
       7019
        
           email = "ethercrow@gmail.com";

     
···

       25192
       25195
        
         yuka = {

     

       25193
       25196
        
           email = "yuka@yuka.dev";

     

       25194
       25197
        
           matrix = "@yuka:yuka.dev";

     

       25195
       25195
       -
           github = "yu-re-ka";

     

       25196
       25196
       -
           githubId = 86169957;

     

       25198
       25198
       +
           github = "yuyuyureka";

     

       25199
       25199
       +
           githubId = 193895068;

     

       25197
       25200
        
           name = "Yureka";

     

       25198
       25201
        
         };

     

       25199
       25202
        
         Yumasi = {

+5 -4

nixos/doc/manual/release-notes/rl-2411.section.md

···

       936
       936
        
       

     

       937
       937
        
       If you set `sound.enable` in your configuration:

     

       938
       938
        
         - If you are using Pulseaudio or PipeWire, simply remove that option

     

       939
       939
       -
         - If you are not using an external sound server, and want volumes to be persisted across shutdowns, set `hardware.alsa.enablePersistence = true` instead

     

       939
       939
       +
         - If you are using ALSA as your only sound system (no sound server), set `hardware.alsa.enable = true` instead

     

       940
       940
        
       

     

       941
       941
        
       If you set `sound.enableOSSEmulation` in your configuration:

     

       942
       942
        
         - Make sure it is still necessary, as very few applications actually use OSS

     

       943
       943
       -
         - If necessary, set `boot.kernelModules = [ "snd_pcm_oss" ]`

     

       943
       943
       +
         - If necessary, set `hardware.alsa.enableOSSEmulation = true`

     

       944
       944
        
       

     

       945
       945
        
       If you set `sound.extraConfig` in your configuration:

     

       946
       946
       -
         - If you are using another sound server, like Pulseaudio, JACK or PipeWire, migrate your configuration to that

     

       947
       947
       -
         - If you are not using an external sound server, set `environment.etc."asound.conf".text = yourExtraConfig` instead

     

       946
       946
       +
         - If you are using a sound server, like Pulseaudio, JACK or PipeWire, migrate your configuration to that

     

       947
       947
       +
         - If you are using ALSA as your only sound system, check if you can use the new structured ALSA options `hardware.alsa.defaultDevice`, `hardware.alsa.cardAliases`, `hardware.alsa.controls`, etc.

     

       948
       948
       +
         - Otherwise, move your configuration directly into `hardware.alsa.config`

     

       948
       949
        
       

     

       949
       950
        
       If you set `sound.mediaKeys` in your configuration:

     

       950
       951
        
         - Preferably switch to handling media keys in your desktop environment/compositor

+5 -3

nixos/modules/i18n/input-method/fcitx5.nix

···

       117
       117
        
           i18n.inputMethod.fcitx5.addons =

     

       118
       118
        
             lib.optionals (cfg.quickPhrase != { }) [

     

       119
       119
        
               (pkgs.writeTextDir "share/fcitx5/data/QuickPhrase.mb" (

     

       120
       120
       -
                 lib.mapAttrsToList (

     

       121
       121
       -
                   name: value: "${name} ${builtins.replaceStrings [ "\\" "\n" ] [ "\\\\" "\\n" ] value}"

     

       122
       122
       -
                 ) cfg.quickPhrase

     

       120
       120
       +
                 lib.concatStringsSep "\n" (

     

       121
       121
       +
                   lib.mapAttrsToList (

     

       122
       122
       +
                     name: value: "${name} ${builtins.replaceStrings [ "\\" "\n" ] [ "\\\\" "\\n" ] value}"

     

       123
       123
       +
                   ) cfg.quickPhrase

     

       124
       124
       +
                 )

     

       123
       125
        
               ))

     

       124
       126
        
             ]

     

       125
       127
        
             ++ lib.optionals (cfg.quickPhraseFiles != { }) [

+417 -16

nixos/modules/services/audio/alsa.nix

···

       1
       1
       -
       # ALSA sound support.

     

       2
       2
       -
       { config, lib, pkgs, ... }:

     

       1
       1
       +
       {

     

       2
       2
       +
         config,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         pkgs,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       let

     

       9
       9
       +
         cfg = config.hardware.alsa;

     

       10
       10
       +
       

     

       11
       11
       +
         quote = x: ''"${lib.escape [ "\"" ] x}"'';

     

       12
       12
       +
       

     

       13
       13
       +
         alsactl = lib.getExe' pkgs.alsa-utils "alsactl";

     

       14
       14
       +
       

     

       15
       15
       +
         # Creates a volume control

     

       16
       16
       +
         mkControl = name: opts: ''

     

       17
       17
       +
           pcm.${name} {

     

       18
       18
       +
             type softvol

     

       19
       19
       +
             slave.pcm ${quote opts.device}

     

       20
       20
       +
             control.name ${quote (if opts.name != null then opts.name else name)}

     

       21
       21
       +
             control.card ${quote opts.card}

     

       22
       22
       +
             max_dB ${toString opts.maxVolume}

     

       23
       23
       +
           }

     

       24
       24
       +
         '';

     

       25
       25
       +
       

     

       26
       26
       +
         # modprobe.conf for naming sound cards

     

       27
       27
       +
         cardsConfig =

     

       28
       28
       +
           let

     

       29
       29
       +
             # Reverse the mapping from card name→driver to card driver→name

     

       30
       30
       +
             drivers = lib.unique (lib.mapAttrsToList (n: v: v.driver) cfg.cardAliases);

     

       31
       31
       +
             options = lib.forEach drivers (

     

       32
       32
       +
               drv:

     

       33
       33
       +
               let

     

       34
       34
       +
                 byDriver = lib.filterAttrs (n: v: v.driver == drv);

     

       35
       35
       +
                 ids = lib.mapAttrs (n: v: v.id) (byDriver cfg.cardAliases);

     

       36
       36
       +
               in

     

       37
       37
       +
               {

     

       38
       38
       +
                 driver = drv;

     

       39
       39
       +
                 names = lib.attrNames ids;

     

       40
       40
       +
                 ids = lib.attrValues ids;

     

       41
       41
       +
               }

     

       42
       42
       +
             );

     

       43
       43
       +
             toList = x: lib.concatStringsSep "," (map toString x);

     

       44
       44
       +
           in

     

       45
       45
       +
           lib.forEach options (i: "options ${i.driver} index=${toList i.ids} id=${toList i.names}");

     

       46
       46
       +
       

     

       47
       47
       +
         defaultDeviceVars = {

     

       48
       48
       +
           "ALSA_AUDIO_OUT" = cfg.defaultDevice.playback;

     

       49
       49
       +
           "ALSA_AUDIO_IN" = cfg.defaultDevice.capture;

     

       50
       50
       +
         };

     

       51
       51
       +
       

     

       52
       52
       +
       in

     

       3
       53
        
       

     

       4
       54
        
       {

     

       5
       55
        
         imports = [

     

       6
       6
       -
           (lib.mkRemovedOptionModule [ "sound" ] "The option was heavily overloaded and can be removed from most configurations.")

     

       56
       56
       +
           (lib.mkRemovedOptionModule [ "sound" "enable" ] ''

     

       57
       57
       +
             The option was heavily overloaded and can be removed from most configurations.

     

       58
       58
       +
             To specifically configure the user space part of ALSA, see `hardware.alsa`.

     

       59
       59
       +
           '')

     

       60
       60
       +
           (lib.mkRemovedOptionModule [ "sound" "mediaKeys" ] ''

     

       61
       61
       +
             The media keys can be configured with any hotkey daemon (that better

     

       62
       62
       +
             integrates with your desktop setup). To continue using the actkbd daemon

     

       63
       63
       +
             (which was used up to NixOS 24.05), add these lines to your configuration:

     

       64
       64
       +
       

     

       65
       65
       +
               services.actkbd.enable = true;

     

       66
       66
       +
               services.actkbd.bindings = [

     

       67
       67
       +
                 # Mute

     

       68
       68
       +
                 { keys = [ 113 ]; events = [ "key" ];

     

       69
       69
       +
                   command = "''${pkgs.alsa-utils}/bin/amixer -q set Master toggle";

     

       70
       70
       +
                 }

     

       71
       71
       +
                 # Volume down

     

       72
       72
       +
                 { keys = [ 114 ]; events = [ "key" "rep" ];

     

       73
       73
       +
                   command = "''${pkgs.alsa-utils}/bin/amixer -q set Master 1- unmute";

     

       74
       74
       +
                 }

     

       75
       75
       +
                 # Volume up

     

       76
       76
       +
                 { keys = [ 115 ]; events = [ "key" "rep" ];

     

       77
       77
       +
                   command = "''${pkgs.alsa-utils}/bin/amixer -q set Master 1+ unmute";

     

       78
       78
       +
                 }

     

       79
       79
       +
                 # Mic Mute

     

       80
       80
       +
                 { keys = [ 190 ]; events = [ "key" ];

     

       81
       81
       +
                   command = "''${pkgs.alsa-utils}/bin/amixer -q set Capture toggle";

     

       82
       82
       +
                 }

     

       83
       83
       +
               ];

     

       84
       84
       +
           '')

     

       85
       85
       +
           (lib.mkRenamedOptionModule

     

       86
       86
       +
             [ "sound" "enableOSSEmulation" ]

     

       87
       87
       +
             [ "hardware" "alsa" "enableOSSEmulation" ]

     

       88
       88
       +
           )

     

       89
       89
       +
           (lib.mkRenamedOptionModule

     

       90
       90
       +
             [ "sound" "extraConfig" ]

     

       91
       91
       +
             [ "hardware" "alsa" "config" ])

     

       7
       92
        
         ];

     

       8
       93
        
       

     

       9
       9
       -
         options.hardware.alsa.enablePersistence = lib.mkOption {

     

       10
       10
       -
           type = lib.types.bool;

     

       11
       11
       -
           default = false;

     

       12
       12
       -
           description = ''

     

       13
       13
       -
             Whether to enable ALSA sound card state saving on shutdown.

     

       14
       14
       -
             This is generally not necessary if you're using an external sound server.

     

       15
       15
       -
           '';

     

       94
       94
       +
         options.hardware.alsa = {

     

       95
       95
       +
       

     

       96
       96
       +
           enable = lib.mkOption {

     

       97
       97
       +
             type = lib.types.bool;

     

       98
       98
       +
             default = false;

     

       99
       99
       +
             description = ''

     

       100
       100
       +
               Whether to set up the user space part of the Advanced Linux Sound Architecture (ALSA)

     

       101
       101
       +
       

     

       102
       102
       +
               ::: {.warning}

     

       103
       103
       +
               Enable this option only if you want to use ALSA as your main sound system,

     

       104
       104
       +
               not if you're using a sound server (e.g. PulseAudio or Pipewire).

     

       105
       105
       +
               :::

     

       106
       106
       +
             '';

     

       107
       107
       +
           };

     

       108
       108
       +
       

     

       109
       109
       +
           enableOSSEmulation = lib.mkEnableOption "the OSS emulation";

     

       110
       110
       +
       

     

       111
       111
       +
           enableRecorder = lib.mkOption {

     

       112
       112
       +
             type = lib.types.bool;

     

       113
       113
       +
             default = false;

     

       114
       114
       +
             description = ''

     

       115
       115
       +
               Whether to set up a loopback device that continuously records and

     

       116
       116
       +
               allows to play back audio from the computer.

     

       117
       117
       +
       

     

       118
       118
       +
               The loopback device is named `pcm.recorder`, audio can be saved

     

       119
       119
       +
               by capturing from this device as with any microphone.

     

       120
       120
       +
       

     

       121
       121
       +
               ::: {.note}

     

       122
       122
       +
               By default the output is duplicated to the recorder assuming stereo

     

       123
       123
       +
               audio, for a more complex layout you have to override the pcm.splitter

     

       124
       124
       +
               device using `hardware.alsa.config`.

     

       125
       125
       +
               See the generated /etc/asound.conf for its definition.

     

       126
       126
       +
               :::

     

       127
       127
       +
             '';

     

       128
       128
       +
           };

     

       129
       129
       +
       

     

       130
       130
       +
           defaultDevice.playback = lib.mkOption {

     

       131
       131
       +
             type = lib.types.str;

     

       132
       132
       +
             default = "";

     

       133
       133
       +
             example = "dmix:CARD=1,DEV=0";

     

       134
       134
       +
             description = ''

     

       135
       135
       +
               The default playback device.

     

       136
       136
       +
               Leave empty to let ALSA pick the default automatically.

     

       137
       137
       +
       

     

       138
       138
       +
               ::: {.note}

     

       139
       139
       +
               The device can be changed at runtime by setting the ALSA_AUDIO_OUT

     

       140
       140
       +
               environment variables (but only before starting a program).

     

       141
       141
       +
               :::

     

       142
       142
       +
             '';

     

       143
       143
       +
           };

     

       144
       144
       +
       

     

       145
       145
       +
           defaultDevice.capture = lib.mkOption {

     

       146
       146
       +
             type = lib.types.str;

     

       147
       147
       +
             default = "";

     

       148
       148
       +
             example = "dsnoop:CARD=0,DEV=2";

     

       149
       149
       +
             description = ''

     

       150
       150
       +
               The default capture device (i.e. microphone).

     

       151
       151
       +
               Leave empty to let ALSA pick the default automatically.

     

       152
       152
       +
       

     

       153
       153
       +
               ::: {.note}

     

       154
       154
       +
               The device can be changed at runtime by setting the ALSA_AUDIO_IN

     

       155
       155
       +
               environment variables (but only before starting a program).

     

       156
       156
       +
               :::

     

       157
       157
       +
             '';

     

       158
       158
       +
           };

     

       159
       159
       +
       

     

       160
       160
       +
           controls = lib.mkOption {

     

       161
       161
       +
             type = lib.types.attrsOf (

     

       162
       162
       +
               lib.types.submodule ({

     

       163
       163
       +
                 options.name = lib.mkOption {

     

       164
       164
       +
                   type = lib.types.nullOr lib.types.str;

     

       165
       165
       +
                   default = null;

     

       166
       166
       +
                   description = ''

     

       167
       167
       +
                     Name of the control, as it appears in `alsamixer`.

     

       168
       168
       +
                     If null it will be the same as the softvol device name.

     

       169
       169
       +
                   '';

     

       170
       170
       +
                 };

     

       171
       171
       +
                 options.device = lib.mkOption {

     

       172
       172
       +
                   type = lib.types.str;

     

       173
       173
       +
                   default = "default";

     

       174
       174
       +
                   description = ''

     

       175
       175
       +
                     Name of the PCM device to control (slave).

     

       176
       176
       +
                   '';

     

       177
       177
       +
                 };

     

       178
       178
       +
                 options.card = lib.mkOption {

     

       179
       179
       +
                   type = lib.types.str;

     

       180
       180
       +
                   default = "default";

     

       181
       181
       +
                   description = ''

     

       182
       182
       +
                     Name of the PCM card to control (slave).

     

       183
       183
       +
                   '';

     

       184
       184
       +
                 };

     

       185
       185
       +
                 options.maxVolume = lib.mkOption {

     

       186
       186
       +
                   type = lib.types.float;

     

       187
       187
       +
                   default = 0.0;

     

       188
       188
       +
                   description = ''

     

       189
       189
       +
                     The maximum volume in dB.

     

       190
       190
       +
                   '';

     

       191
       191
       +
                 };

     

       192
       192
       +
               })

     

       193
       193
       +
             );

     

       194
       194
       +
             default = {};

     

       195
       195
       +
             example = lib.literalExpression ''

     

       196
       196
       +
               {

     

       197
       197
       +
                 firefox = { device = "front"; maxVolume = -25.0; };

     

       198
       198
       +
                 mpv     = { device = "front"; maxVolume = -25.0; };

     

       199
       199
       +
                 # and run programs with `env ALSA_AUDIO_OUT=<name>`

     

       200
       200
       +
               }

     

       201
       201
       +
             '';

     

       202
       202
       +
             description = ''

     

       203
       203
       +
               Virtual volume controls (softvols) to add to a sound card.

     

       204
       204
       +
               These can be used to control the volume of specific applications

     

       205
       205
       +
               or a digital output device (HDMI video card).

     

       206
       206
       +
             '';

     

       207
       207
       +
           };

     

       208
       208
       +
       

     

       209
       209
       +
           cardAliases = lib.mkOption {

     

       210
       210
       +
             type = lib.types.attrsOf (

     

       211
       211
       +
               lib.types.submodule ({

     

       212
       212
       +
                 options.driver = lib.mkOption {

     

       213
       213
       +
                   type = lib.types.str;

     

       214
       214
       +
                   description = ''

     

       215
       215
       +
                     Name of the kernel module that provides the card.

     

       216
       216
       +
                   '';

     

       217
       217
       +
                 };

     

       218
       218
       +
                 options.id = lib.mkOption {

     

       219
       219
       +
                   type = lib.types.int;

     

       220
       220
       +
                   default = "default";

     

       221
       221
       +
                   description = ''

     

       222
       222
       +
                     The ID of the sound card

     

       223
       223
       +
                   '';

     

       224
       224
       +
                 };

     

       225
       225
       +
               })

     

       226
       226
       +
             );

     

       227
       227
       +
             default = { };

     

       228
       228
       +
             example = lib.literalExpression ''

     

       229
       229
       +
               {

     

       230
       230
       +
                 soundchip = { driver = "snd_intel_hda"; id = 0; };

     

       231
       231
       +
                 videocard = { driver = "snd_intel_hda"; id = 1; };

     

       232
       232
       +
                 usb       = { driver = "snd_usb_audio"; id = 2; };

     

       233
       233
       +
               }

     

       234
       234
       +
             '';

     

       235
       235
       +
             description = ''

     

       236
       236
       +
               Assign custom names and reorder the sound cards.

     

       237
       237
       +
       

     

       238
       238
       +
               ::: {.note}

     

       239
       239
       +
               You can find the card ids by looking at `/proc/asound/cards`.

     

       240
       240
       +
               :::

     

       241
       241
       +
             '';

     

       242
       242
       +
           };

     

       243
       243
       +
       

     

       244
       244
       +
           deviceAliases = lib.mkOption {

     

       245
       245
       +
             type = lib.types.attrsOf lib.types.str;

     

       246
       246
       +
             default = { };

     

       247
       247
       +
             example = lib.literalExpression ''

     

       248
       248
       +
               {

     

       249
       249
       +
                 hdmi1 = "hw:CARD=videocard,DEV=5";

     

       250
       250
       +
                 hdmi2 = "hw:CARD=videocard,DEV=6";

     

       251
       251
       +
               }

     

       252
       252
       +
             '';

     

       253
       253
       +
             description = ''

     

       254
       254
       +
               Assign custom names to sound cards.

     

       255
       255
       +
             '';

     

       256
       256
       +
           };

     

       257
       257
       +
       

     

       258
       258
       +
           config = lib.mkOption {

     

       259
       259
       +
             type = lib.types.lines;

     

       260
       260
       +
             default = "";

     

       261
       261
       +
             example = lib.literalExpression ''

     

       262
       262
       +
               # Send audio to a remote host via SSH

     

       263
       263
       +
               pcm.remote {

     

       264
       264
       +
                 @args [ HOSTNAME ]

     

       265
       265
       +
                 @args.HOSTNAME { type string }

     

       266
       266
       +
                 type file

     

       267
       267
       +
                 format raw

     

       268
       268
       +
                 slave.pcm pcm.null

     

       269
       269
       +
                 file {

     

       270
       270
       +
                   @func concat

     

       271
       271
       +
                   strings [

     

       272
       272
       +
                     "| ''${lib.getExec pkgs.openssh} -C "

     

       273
       273
       +
                     $HOSTNAME

     

       274
       274
       +
                     " aplay -f %f -c %c -r %r -"

     

       275
       275
       +
                   ]

     

       276
       276
       +
                 }

     

       277
       277
       +
               }

     

       278
       278
       +
             '';

     

       279
       279
       +
             description = ''

     

       280
       280
       +
               The content of the system-wide ALSA configuration (/etc/asound.conf).

     

       281
       281
       +
       

     

       282
       282
       +
               Documentation of the configuration language and examples can be found

     

       283
       283
       +
               in the unofficial ALSA wiki: https://alsa.opensrc.org/Asoundrc

     

       284
       284
       +
             '';

     

       285
       285
       +
           };

     

       286
       286
       +
       

     

       16
       287
        
         };

     

       17
       288
        
       

     

       18
       18
       -
         config = lib.mkIf config.hardware.alsa.enablePersistence {

     

       19
       19
       -
           # ALSA provides a udev rule for restoring volume settings.

     

       20
       20
       -
           services.udev.packages = [ pkgs.alsa-utils ];

     

       289
       289
       +
         config = lib.mkIf cfg.enable {

     

       21
       290
        
       

     

       291
       291
       +
           # Disable sound servers enabled by default and,

     

       292
       292
       +
           # if the user enabled one manually, cause a conflict.

     

       293
       293
       +
           services.pipewire.enable = false;

     

       294
       294
       +
           hardware.pulseaudio.enable = false;

     

       295
       295
       +
       

     

       296
       296
       +
           hardware.alsa.config =

     

       297
       297
       +
             let

     

       298
       298
       +
               conf = [

     

       299
       299
       +
                 ''

     

       300
       300
       +
                   pcm.!default fromenv

     

       301
       301
       +
       

     

       302
       302
       +
                   # Read the capture and playback device from

     

       303
       303
       +
                   # the ALSA_AUDIO_IN, ALSA_AUDIO_OUT variables

     

       304
       304
       +
                   pcm.fromenv {

     

       305
       305
       +
                     type asym

     

       306
       306
       +
                     playback.pcm {

     

       307
       307
       +
                       type plug

     

       308
       308
       +
                       slave.pcm {

     

       309
       309
       +
                         @func getenv

     

       310
       310
       +
                         vars [ ALSA_AUDIO_OUT ]

     

       311
       311
       +
                         default pcm.sysdefault

     

       312
       312
       +
                       }

     

       313
       313
       +
                     }

     

       314
       314
       +
                     capture.pcm {

     

       315
       315
       +
                       type plug

     

       316
       316
       +
                       slave.pcm {

     

       317
       317
       +
                         @func getenv

     

       318
       318
       +
                         vars [ ALSA_AUDIO_IN ]

     

       319
       319
       +
                         default pcm.sysdefault

     

       320
       320
       +
                       }

     

       321
       321
       +
                     }

     

       322
       322
       +
                   }

     

       323
       323
       +
                 ''

     

       324
       324
       +
                 (lib.optional cfg.enableRecorder ''

     

       325
       325
       +
                   pcm.!default "splitter:fromenv,recorder"

     

       326
       326
       +
       

     

       327
       327
       +
                   # Send audio to two stereo devices

     

       328
       328
       +
                   pcm.splitter {

     

       329
       329
       +
                     @args [ A B ]

     

       330
       330
       +
                     @args.A.type string

     

       331
       331
       +
                     @args.B.type string

     

       332
       332
       +
                     type asym

     

       333
       333
       +
                     playback.pcm {

     

       334
       334
       +
                       type plug

     

       335
       335
       +
                       route_policy "duplicate"

     

       336
       336
       +
                       slave.pcm {

     

       337
       337
       +
                         type multi

     

       338
       338
       +
                         slaves.a.pcm $A

     

       339
       339
       +
                         slaves.b.pcm $B

     

       340
       340
       +
                         slaves.a.channels 2

     

       341
       341
       +
                         slaves.b.channels 2

     

       342
       342
       +
                         bindings [

     

       343
       343
       +
                          { slave a channel 0 }

     

       344
       344
       +
                          { slave a channel 1 }

     

       345
       345
       +
                          { slave b channel 0 }

     

       346
       346
       +
                          { slave b channel 1 }

     

       347
       347
       +
                         ]

     

       348
       348
       +
                       }

     

       349
       349
       +
                     }

     

       350
       350
       +
                     capture.pcm $A

     

       351
       351
       +
                   }

     

       352
       352
       +
       

     

       353
       353
       +
                   # Device which records and plays back audio

     

       354
       354
       +
                   pcm.recorder {

     

       355
       355
       +
                     type asym

     

       356
       356
       +
                     capture.pcm {

     

       357
       357
       +
                       type dsnoop

     

       358
       358
       +
                       ipc_key 9165218

     

       359
       359
       +
                       ipc_perm 0666

     

       360
       360
       +
                       slave.pcm "hw:loopback,1,0"

     

       361
       361
       +
                       slave.period_size 1024

     

       362
       362
       +
                       slave.buffer_size 8192

     

       363
       363
       +
                     }

     

       364
       364
       +
                     playback.pcm {

     

       365
       365
       +
                       type dmix

     

       366
       366
       +
                       ipc_key 6181923

     

       367
       367
       +
                       ipc_perm 0666

     

       368
       368
       +
                       slave.pcm "hw:loopback,0,0"

     

       369
       369
       +
                       slave.period_size 1024

     

       370
       370
       +
                       slave.buffer_size 8192

     

       371
       371
       +
                     }

     

       372
       372
       +
                   }

     

       373
       373
       +
                 '')

     

       374
       374
       +
                 (lib.mapAttrsToList mkControl cfg.controls)

     

       375
       375
       +
                 (lib.mapAttrsToList (n: v: "pcm.${n} ${quote v}") cfg.deviceAliases)

     

       376
       376
       +
               ];

     

       377
       377
       +
             in

     

       378
       378
       +
             lib.mkBefore (lib.concatStringsSep "\n" (lib.flatten conf));

     

       379
       379
       +
       

     

       380
       380
       +
           hardware.alsa.cardAliases = lib.mkIf cfg.enableRecorder {

     

       381
       381
       +
             loopback.driver = "snd_aloop";

     

       382
       382
       +
             loopback.id = 2;

     

       383
       383
       +
           };

     

       384
       384
       +
       

     

       385
       385
       +
           # Set default PCM devices

     

       386
       386
       +
           environment.sessionVariables = defaultDeviceVars;

     

       387
       387
       +
           systemd.globalEnvironment = defaultDeviceVars;

     

       388
       388
       +
       

     

       389
       389
       +
           environment.etc."asound.conf".text = cfg.config;

     

       390
       390
       +
       

     

       391
       391
       +
           boot.kernelModules =

     

       392
       392
       +
             [ ]

     

       393
       393
       +
             ++ lib.optionals cfg.enableOSSEmulation [ "snd_pcm_oss" "snd_mixer_oss" ]

     

       394
       394
       +
             ++ lib.optionals cfg.enableRecorder [ "snd_aloop" ];

     

       395
       395
       +
       

     

       396
       396
       +
           # Assign names to the sound cards

     

       397
       397
       +
           boot.extraModprobeConfig = lib.concatStringsSep "\n" cardsConfig;

     

       398
       398
       +
       

     

       399
       399
       +
           # Provide alsamixer, aplay, arecord, etc.

     

       400
       400
       +
           environment.systemPackages = [ pkgs.alsa-utils ];

     

       401
       401
       +
       

     

       402
       402
       +
           # Install udev rules for restoring card settings on boot

     

       403
       403
       +
           services.udev.extraRules = ''

     

       404
       404
       +
             ACTION=="add", SUBSYSTEM=="sound", KERNEL=="controlC*", KERNELS!="card*", GOTO="alsa_restore_go"

     

       405
       405
       +
             GOTO="alsa_restore_end"

     

       406
       406
       +
       

     

       407
       407
       +
             LABEL="alsa_restore_go"

     

       408
       408
       +
             TEST!="/etc/alsa/state-daemon.conf", RUN+="${alsactl} restore -gU $attr{device/number}"

     

       409
       409
       +
             TEST=="/etc/alsa/state-daemon.conf", RUN+="${alsactl} nrestore -gU $attr{device/number}"

     

       410
       410
       +
             LABEL="alsa_restore_end"

     

       411
       411
       +
           '';

     

       412
       412
       +
       

     

       413
       413
       +
           # Service to store/restore the sound card settings

     

       22
       414
        
           systemd.services.alsa-store = {

     

       23
       415
        
             description = "Store Sound Card State";

     

       24
       416
        
             wantedBy = [ "multi-user.target" ];

     

       417
       417
       +
             restartIfChanged = false;

     

       25
       418
        
             unitConfig = {

     

       26
       419
        
               RequiresMountsFor = "/var/lib/alsa";

     

       27
       420
        
               ConditionVirtualization = "!systemd-nspawn";

     
···

       29
       422
        
             serviceConfig = {

     

       30
       423
        
               Type = "oneshot";

     

       31
       424
        
               RemainAfterExit = true;

     

       32
       32
       -
               ExecStartPre = "${pkgs.coreutils}/bin/mkdir -p /var/lib/alsa";

     

       33
       33
       -
               ExecStart = "${pkgs.alsa-utils}/sbin/alsactl restore --ignore";

     

       34
       34
       -
               ExecStop = "${pkgs.alsa-utils}/sbin/alsactl store --ignore";

     

       425
       425
       +
               StateDirectory = "alsa";

     

       426
       426
       +
               # Note: the service should never be restated, otherwise any

     

       427
       427
       +
               # setting changed between the last `store` and now will be lost.

     

       428
       428
       +
               # To prevent NixOS from starting it in case it has failed we

     

       429
       429
       +
               # expand the exit codes considered successful

     

       430
       430
       +
               SuccessExitStatus = [ 0 99 ];

     

       431
       431
       +
               ExecStart = "${alsactl} restore -gU";

     

       432
       432
       +
               ExecStop = "${alsactl} store -gU";

     

       35
       433
        
             };

     

       36
       434
        
           };

     

       37
       435
        
         };

     

       436
       436
       +
       

     

       437
       437
       +
         meta.maintainers = with lib.maintainers; [ rnhmjoj ];

     

       438
       438
       +
       

     

       38
       439
        
       }

+6 -28

nixos/tests/firefox.nix

···

       18
       18
        
               package = firefoxPackage;

     

       19
       19
        
             };

     

       20
       20
        
       

     

       21
       21
       -
             # Create a virtual sound device, with mixing

     

       22
       22
       -
             # and all, for recording audio.

     

       23
       23
       -
             boot.kernelModules = [ "snd-aloop" ];

     

       24
       24
       -
             environment.etc."asound.conf".text = ''

     

       25
       25
       -
               pcm.!default {

     

       26
       26
       -
                 type plug

     

       27
       27
       -
                 slave.pcm pcm.dmixer

     

       28
       28
       -
               }

     

       29
       29
       -
               pcm.dmixer {

     

       30
       30
       -
                 type dmix

     

       31
       31
       -
                 ipc_key 1

     

       32
       32
       -
                 slave {

     

       33
       33
       -
                   pcm "hw:Loopback,0,0"

     

       34
       34
       -
                   rate 48000

     

       35
       35
       -
                   periods 128

     

       36
       36
       -
                   period_time 0

     

       37
       37
       -
                   period_size 1024

     

       38
       38
       -
                   buffer_size 8192

     

       39
       39
       -
                 }

     

       40
       40
       -
               }

     

       41
       41
       -
               pcm.recorder {

     

       42
       42
       -
                 type hw

     

       43
       43
       -
                 card "Loopback"

     

       44
       44
       -
                 device 1

     

       45
       45
       -
                 subdevice 0

     

       46
       46
       -
               }

     

       47
       47
       -
             '';

     

       21
       21
       +
             hardware.alsa = {

     

       22
       22
       +
               enable = true;

     

       23
       23
       +
               enableRecorder = true;

     

       24
       24
       +
               defaultDevice.playback = "pcm.recorder";

     

       25
       25
       +
             };

     

       48
       26
        
       

     

       49
       27
        
             systemd.services.audio-recorder = {

     

       50
       28
        
               description = "Record NixOS test audio to /tmp/record.wav";

     

       51
       51
       -
               script = "${pkgs.alsa-utils}/bin/arecord -D recorder -f S16_LE -r48000 /tmp/record.wav";

     

       29
       29
       +
               script = "${pkgs.alsa-utils}/bin/arecord -Drecorder -fS16_LE -r48000 -c2 /tmp/record.wav";

     

       52
       30
        
             };

     

       53
       31
        
       

     

       54
       32
        
           };

+2 -2

pkgs/applications/misc/protonup-qt/default.nix

···

       5
       5
        
       }:

     

       6
       6
        
       let

     

       7
       7
        
         pname = "protonup-qt";

     

       8
       8
       -
         version = "2.10.2";

     

       8
       8
       +
         version = "2.11.1";

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://github.com/DavidoTek/ProtonUp-Qt/releases/download/v${version}/ProtonUp-Qt-${version}-x86_64.AppImage";

     

       11
       11
       -
           hash = "sha256-WWLAA5FryvqwgEQysnE1w2k9Wq4y7yNJ4Drojg1SKYg=";

     

       11
       11
       +
           hash = "sha256-xHkeAqveXF8YLFvKHTZtSvINIIoiqhNbwVuKfnaHcQI=";

     

       12
       12
        
         };

     

       13
       13
        
         appimageContents = appimageTools.extractType2 { inherit pname version src; };

     

       14
       14
        
       in

+12 -3

pkgs/applications/science/math/R/default.nix

···

       28
       28
        
       

     

       29
       29
        
         dontUseImakeConfigure = true;

     

       30
       30
        
       

     

       31
       31
       -
         nativeBuildInputs = [ pkg-config ];

     

       31
       31
       +
         nativeBuildInputs = [

     

       32
       32
       +
           bison

     

       33
       33
       +
           imake

     

       34
       34
       +
           perl

     

       35
       35
       +
           pkg-config

     

       36
       36
       +
           tzdata

     

       37
       37
       +
           which

     

       38
       38
       +
         ];

     

       32
       39
        
         buildInputs = [

     

       33
       40
        
           bzip2 gfortran libX11 libXmu libXt libXt libjpeg libpng libtiff ncurses

     

       34
       34
       -
           pango pcre2 perl readline (texliveSmall.withPackages (ps: with ps; [ inconsolata helvetic ps.texinfo fancyvrb cm-super rsfs ])) xz zlib less texinfo graphviz icu

     

       35
       35
       -
           bison imake which blas lapack curl tcl tk jdk tzdata

     

       41
       41
       +
           pango pcre2 readline (texliveSmall.withPackages (ps: with ps; [ inconsolata helvetic ps.texinfo fancyvrb cm-super rsfs ])) xz zlib less texinfo graphviz icu

     

       42
       42
       +
           which blas lapack curl tcl tk jdk

     

       36
       43
        
         ] ++ lib.optionals stdenv.hostPlatform.isDarwin [ Cocoa Foundation libobjc libcxx ];

     

       44
       44
       +
         strictDeps = true;

     

       37
       45
        
       

     

       38
       46
        
         patches = [

     

       39
       47
        
           ./no-usr-local-search-paths.patch

     
···

       75
       83
        
             FC="${gfortran}/bin/gfortran" F77="${gfortran}/bin/gfortran"

     

       76
       84
        
             JAVA_HOME="${jdk}"

     

       77
       85
        
             RANLIB=$(type -p ranlib)

     

       86
       86
       +
             CURL_CONFIG="${lib.getExe' (lib.getDev curl) "curl-config"}"

     

       78
       87
        
             r_cv_have_curl728=yes

     

       79
       88
        
             R_SHELL="${stdenv.shell}"

     

       80
       89
        
         '' + lib.optionalString stdenv.hostPlatform.isDarwin ''

+2 -2

pkgs/by-name/ba/bant/package.nix

···

       19
       19
        
       in

     

       20
       20
        
       buildBazelPackage rec {

     

       21
       21
        
         pname = "bant";

     

       22
       22
       -
         version = "0.1.9";

     

       22
       22
       +
         version = "0.1.11";

     

       23
       23
        
       

     

       24
       24
        
         src = fetchFromGitHub {

     

       25
       25
        
           owner = "hzeller";

     

       26
       26
        
           repo = "bant";

     

       27
       27
        
           rev = "v${version}";

     

       28
       28
       -
           hash = "sha256-TIVbf5qZNohZAFugi/E7m1Sgekn82/qqtx8jSHo75Js=";

     

       28
       28
       +
           hash = "sha256-vqZGHMIs4t1TP+9r2hvtFXN5B5GXZerC18l8gQA9cmQ=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         bazelFlags = [

+2 -2

pkgs/by-name/cl/clangbuildanalyzer/package.nix

···

       6
       6
        
       }:

     

       7
       7
        
       stdenv.mkDerivation (finalAttrs: {

     

       8
       8
        
         pname = "clangbuildanalyzer";

     

       9
       9
       -
         version = "1.5.0";

     

       9
       9
       +
         version = "1.6.0";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "aras-p";

     

       13
       13
        
           repo = "ClangBuildAnalyzer";

     

       14
       14
        
           rev = "v${finalAttrs.version}";

     

       15
       15
       -
           hash = "sha256-kmgdk634zM0W0OoRoP/RzepArSipa5bNqdVgdZO9gxo=";

     

       15
       15
       +
           hash = "sha256-GIMQZGPFKDrfMqCsA8nR3O8Hzp2jcaZ+yDrPeCxTsIg=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         nativeBuildInputs = [

+2 -2

pkgs/by-name/cp/cp2k/package.nix

···

       63
       63
        
       in

     

       64
       64
        
       stdenv.mkDerivation rec {

     

       65
       65
        
         pname = "cp2k";

     

       66
       66
       -
         version = "2024.3";

     

       66
       66
       +
         version = "2025.1";

     

       67
       67
        
       

     

       68
       68
        
         src = fetchFromGitHub {

     

       69
       69
        
           owner = "cp2k";

     

       70
       70
        
           repo = "cp2k";

     

       71
       71
        
           rev = "v${version}";

     

       72
       72
       -
           hash = "sha256-TeVQ0wVUx6d4knwMi9z3LjQZ4ELE6s1TnvwfFz8jbYk=";

     

       72
       72
       +
           hash = "sha256-04AFiEuv+EYubZVoYErQDdr9zipKlF7Gqy8DrUaYUMk=";

     

       73
       73
        
           fetchSubmodules = true;

     

       74
       74
        
         };

     

       75
       75

+2 -2

pkgs/by-name/cs/csharpier/package.nix

···

       2
       2
        
       

     

       3
       3
        
       buildDotnetGlobalTool {

     

       4
       4
        
         pname = "csharpier";

     

       5
       5
       -
         version = "0.30.3";

     

       5
       5
       +
         version = "0.30.5";

     

       6
       6
        
         executables = "dotnet-csharpier";

     

       7
       7
        
       

     

       8
       8
       -
         nugetHash = "sha256-W+O6zrHkRru/s0MT0SGa58PlPHgFE4wxtqZj2GJDRos=";

     

       8
       8
       +
         nugetHash = "sha256-8NuhwRhvEZtmPtgbLLNbTOLUoDAihtkKE8aw5UQ0O5A=";

     

       9
       9
        
       

     

       10
       10
        
         meta = with lib; {

     

       11
       11
        
           description = "Opinionated code formatter for C#";

+3 -3

pkgs/by-name/dn/dnscontrol/package.nix

···

       9
       9
        
       

     

       10
       10
        
       buildGoModule rec {

     

       11
       11
        
         pname = "dnscontrol";

     

       12
       12
       -
         version = "4.15.2";

     

       12
       12
       +
         version = "4.15.3";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "StackExchange";

     

       16
       16
        
           repo = "dnscontrol";

     

       17
       17
        
           rev = "v${version}";

     

       18
       18
       -
           hash = "sha256-/bYu/zOwWTgLx7vexp/V8+llaVoioQLiQdSHV9w5Qug=";

     

       18
       18
       +
           hash = "sha256-0vg3y/bUp5BTFhJbIdohvuj1DNu9bykDwMM3bWnKvNU=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
       -
         vendorHash = "sha256-lfefR0NjeQEYIl1GyjzfsNJgdDGO/ULZtIhleL3CyC8=";

     

       21
       21
       +
         vendorHash = "sha256-JMi4FDgZT94KyqDR57xgp1vnP7Htdn/bksntbQdGyZ0=";

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [ installShellFiles ];

     

       24
       24

+43

pkgs/by-name/fi/filebeat8/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         buildGoModule,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         versionCheckHook,

     

       6
       6
       +
         nix-update-script,

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildGoModule rec {

     

       10
       10
       +
         pname = "filebeat";

     

       11
       11
       +
         version = "8.16.1";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "elastic";

     

       15
       15
       +
           repo = "beats";

     

       16
       16
       +
           tag = "v${version}";

     

       17
       17
       +
           hash = "sha256-suzubh5aILiuRe8/wb52fnSujGNhGRXBxE8jv1WDzNc=";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         vendorHash = "sha256-wspQImG/cxWglwojweuH+h5abTSrtcK6F8cpBeCDH/U=";

     

       21
       21
       +
       

     

       22
       22
       +
         subPackages = [ "filebeat" ];

     

       23
       23
       +
       

     

       24
       24
       +
         nativeInstallCheckInputs = [

     

       25
       25
       +
           versionCheckHook

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         versionCheckProgramArg = [ "version" ];

     

       29
       29
       +
         doInstallCheck = true;

     

       30
       30
       +
       

     

       31
       31
       +
         passthru = {

     

       32
       32
       +
           updateScript = nix-update-script { };

     

       33
       33
       +
         };

     

       34
       34
       +
       

     

       35
       35
       +
         meta = {

     

       36
       36
       +
           description = "Tails and ships log files";

     

       37
       37
       +
           homepage = "https://github.com/elastic/beats";

     

       38
       38
       +
           changelog = "https://www.elastic.co/guide/en/beats/libbeat/${version}/release-notes-${version}.html";

     

       39
       39
       +
           license = lib.licenses.asl20;

     

       40
       40
       +
           maintainers = with lib.maintainers; [ srhb ];

     

       41
       41
       +
           mainProgram = "filebeat";

     

       42
       42
       +
         };

     

       43
       43
       +
       }

+2 -2

pkgs/by-name/ha/hashes/package.nix

···

       21
       21
        
       

     

       22
       22
        
       python3Packages.buildPythonApplication rec {

     

       23
       23
        
         pname = "hashes";

     

       24
       24
       -
         version = "1.1.0";

     

       24
       24
       +
         version = "1.1.1";

     

       25
       25
        
       

     

       26
       26
        
         pyproject = false;

     

       27
       27
        
       

     
···

       29
       29
        
           owner = "zefr0x";

     

       30
       30
        
           repo = "hashes";

     

       31
       31
        
           tag = "v${version}";

     

       32
       32
       -
           hash = "sha256-BmfSCHs+JcpsAG8AhaYf+SDFI+LdJKMKgBIodd66qmw=";

     

       32
       32
       +
           hash = "sha256-4khMRtKvYQkTwhiqv7FUy/jroGboNTdG1Q6wlTD4cwA=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         nativeBuildInputs = [

+2 -2

pkgs/by-name/ko/komga/package.nix

···

       9
       9
        
       

     

       10
       10
        
       stdenvNoCC.mkDerivation rec {

     

       11
       11
        
         pname = "komga";

     

       12
       12
       -
         version = "1.15.1";

     

       12
       12
       +
         version = "1.16.0";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "https://github.com/gotson/${pname}/releases/download/${version}/${pname}-${version}.jar";

     

       16
       16
       -
           sha256 = "sha256-Gv0AaW3aTjLjNAzC5FJMVfvZyIN23ezPpRk15OYyKKs=";

     

       16
       16
       +
           sha256 = "sha256-6q7ZtTdbH2nIPIm6gNQZz2QxHlbWULsflhWJ0aDMFH4=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [

+2 -2

pkgs/by-name/mo/morewaita-icon-theme/package.nix

···

       7
       7
        
       }:

     

       8
       8
        
       stdenvNoCC.mkDerivation rec {

     

       9
       9
        
         pname = "morewaita-icon-theme";

     

       10
       10
       -
         version = "47.2";

     

       10
       10
       +
         version = "47.3";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "somepaulo";

     

       14
       14
        
           repo = "MoreWaita";

     

       15
       15
        
           tag = "v${version}";

     

       16
       16
       -
           hash = "sha256-LvkYLY8PYajCb1x1p0HfpKoMq+t4XwH/w9Hvy9YXzk0=";

     

       16
       16
       +
           hash = "sha256-ImpBIpNs29JMAeWZTQ93BfWC9JBzu4Y/cuulyzD9Xyg=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [

+1 -1

pkgs/by-name/my/mysql-workbench/dont-search-for-antlr-jar.patch

···

       6
       6
        
        check_function_exists (strtoimax HAVE_STRTOIMAX)

     

       7
       7
        
        check_function_exists (strtoumax HAVE_STRTOUMAX)

     

       8
       8
        
        

     

       9
       9
       -
       -set(ANTLR_JAR_FILENAME "antlr-4.11.1-complete.jar")

     

       9
       9
       +
       -set(ANTLR_JAR_FILENAME "antlr-4.13.2-complete.jar")

     

       10
       10
        
       -get_filename_component(SOURCE_PARENT_DIR ${CMAKE_SOURCE_DIR} DIRECTORY)

     

       11
       11
        
       -set(LINUX_RES_BIN_DIR ${SOURCE_PARENT_DIR}/linux-res/bin)

     

       12
       12
        
       -message("WITH_ANTLR_JAR: ${WITH_ANTLR_JAR}")

+5 -5

pkgs/by-name/my/mysql-workbench/package.nix

···

       21
       21
        
         libiodbc,

     

       22
       22
        
         proj,

     

       23
       23
        
       

     

       24
       24
       -
         antlr4_12,

     

       24
       24
       +
         antlr4_13,

     

       25
       25
        
         gtkmm3,

     

       26
       26
        
         libxml2,

     

       27
       27
        
         libmysqlconnectorcpp,

     
···

       52
       52
        
       in

     

       53
       53
        
       stdenv.mkDerivation (finalAttrs: {

     

       54
       54
        
         pname = "mysql-workbench";

     

       55
       55
       -
         version = "8.0.38";

     

       55
       55
       +
         version = "8.0.40";

     

       56
       56
        
       

     

       57
       57
        
         src = fetchurl {

     

       58
       58
        
           url = "https://cdn.mysql.com/Downloads/MySQLGUITools/mysql-workbench-community-${finalAttrs.version}-src.tar.gz";

     

       59
       59
       -
           hash = "sha256-W2RsA2hIRUaNRK0Q5pN1YODbEiw6HE3cfeisPdUcYPY=";

     

       59
       59
       +
           hash = "sha256-/CrjHgZ3IFFvUB1IxeURme8Z6BoZx0b03MWk8QCe0Sg=";

     

       60
       60
        
         };

     

       61
       61
        
       

     

       62
       62
        
         patches = [

     
···

       101
       101
        
         ];

     

       102
       102
        
       

     

       103
       103
        
         buildInputs = [

     

       104
       104
       -
           antlr4_12.runtime.cpp

     

       104
       104
       +
           antlr4_13.runtime.cpp

     

       105
       105
        
           gtkmm3

     

       106
       106
        
           (libxml2.override { enableHttp = true; })

     

       107
       107
        
           libmysqlconnectorcpp

     
···

       141
       141
        
         cmakeFlags = [

     

       142
       142
        
           (lib.cmakeFeature "MySQL_CONFIG_PATH" (lib.getExe' mysql "mysql_config"))

     

       143
       143
        
           (lib.cmakeFeature "IODBC_CONFIG_PATH" (lib.getExe' libiodbc "iodbc-config"))

     

       144
       144
       -
           (lib.cmakeFeature "ANTLR_JAR_PATH" "${antlr4_12.jarLocation}")

     

       144
       144
       +
           (lib.cmakeFeature "ANTLR_JAR_PATH" "${antlr4_13.jarLocation}")

     

       145
       145
        
           # mysql-workbench 8.0.21 depends on libmysqlconnectorcpp 1.1.8.

     

       146
       146
        
           # Newer versions of connector still provide the legacy library when enabled

     

       147
       147
        
           # but the headers are in a different location.

+12

pkgs/by-name/no/notion-app/info.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "x86_64-darwin": {

     

       3
       3
       +
           "version": "4.2.0",

     

       4
       4
       +
           "url": "https://desktop-release.notion-static.com/Notion-4.2.0.zip",

     

       5
       5
       +
           "hash": "sha512-FLptPNEtS9fTevSeGC00hDtpgSks+8JtEKRTtWlYPtI0vpA1KqixBdv2OaNSK1W7Krlsl25RpTOl8cJdQxcv4Q=="

     

       6
       6
       +
         },

     

       7
       7
       +
         "aarch64-darwin": {

     

       8
       8
       +
           "version": "4.2.0",

     

       9
       9
       +
           "url": "https://desktop-release.notion-static.com/Notion-arm64-4.2.0.zip",

     

       10
       10
       +
           "hash": "sha512-cxfO3Bm7ZzAQMi0Pdwd3nvQlRPjn4w7j0ojYUCcn660YsBtoVkpNhiuqg9pbWzY0Umh+/8Zig9CGXKjjP94Iww=="

     

       11
       11
       +
         }

     

       12
       12
       +
       }

+42

pkgs/by-name/no/notion-app/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenvNoCC,

     

       4
       4
       +
         fetchurl,

     

       5
       5
       +
         unzip,

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         info =

     

       9
       9
       +
           (builtins.fromJSON (builtins.readFile ./info.json))."${stdenvNoCC.targetPlatform.system}"

     

       10
       10
       +
             or (throw "notion-app: unsupported system ${stdenvNoCC.targetPlatform.system}");

     

       11
       11
       +
       in

     

       12
       12
       +
       stdenvNoCC.mkDerivation (finalAttrs: {

     

       13
       13
       +
         pname = "notion-app";

     

       14
       14
       +
         version = info.version;

     

       15
       15
       +
       

     

       16
       16
       +
         src = fetchurl { inherit (info) url hash; };

     

       17
       17
       +
       

     

       18
       18
       +
         sourceRoot = ".";

     

       19
       19
       +
         nativeBuildInputs = [ unzip ];

     

       20
       20
       +
         installPhase = ''

     

       21
       21
       +
           runHook preInstall

     

       22
       22
       +
       

     

       23
       23
       +
           mkdir -p $out/Applications

     

       24
       24
       +
           mv Notion.app $out/Applications

     

       25
       25
       +
       

     

       26
       26
       +
           runHook postInstall

     

       27
       27
       +
         '';

     

       28
       28
       +
       

     

       29
       29
       +
         passthru.updateScript = ./update/update.mjs;

     

       30
       30
       +
       

     

       31
       31
       +
         meta = {

     

       32
       32
       +
           description = "App to write, plan, collaborate, and get organised";

     

       33
       33
       +
           homepage = "https://www.notion.so/";

     

       34
       34
       +
           license = lib.licenses.unfree;

     

       35
       35
       +
           maintainers = with lib.maintainers; [ xiaoxiangmoe ];

     

       36
       36
       +
           platforms = [

     

       37
       37
       +
             "x86_64-darwin"

     

       38
       38
       +
             "aarch64-darwin"

     

       39
       39
       +
           ];

     

       40
       40
       +
           sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];

     

       41
       41
       +
         };

     

       42
       42
       +
       })

+9

pkgs/by-name/no/notion-app/update/jsconfig.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "compilerOptions": {

     

       3
       3
       +
           "allowJs": true,

     

       4
       4
       +
           "checkJs": true,

     

       5
       5
       +
           "module": "NodeNext",

     

       6
       6
       +
           "noEmit": true,

     

       7
       7
       +
           "strict": true

     

       8
       8
       +
         }

     

       9
       9
       +
       }

+88

pkgs/by-name/no/notion-app/update/update.mjs

···

       1
       1
       +
       #!/usr/bin/env nix-shell

     

       2
       2
       +
       /*

     

       3
       3
       +
       #!nix-shell -i node --pure --packages cacert nodejs yq-go

     

       4
       4
       +
       */

     

       5
       5
       +
       import * as assert from "node:assert/strict";

     

       6
       6
       +
       import * as child_process from "node:child_process";

     

       7
       7
       +
       import * as fsPromises from "node:fs/promises";

     

       8
       8
       +
       import * as path from "node:path";

     

       9
       9
       +
       

     

       10
       10
       +
       const __dirname = import.meta.dirname;

     

       11
       11
       +
       

     

       12
       12
       +
       /** @typedef {{

     

       13
       13
       +
         version: string;

     

       14
       14
       +
         path: `${string}.zip`;

     

       15
       15
       +
         sha512: string;

     

       16
       16
       +
         releaseDate: string;

     

       17
       17
       +
         files: Array<{ url: string; sha512: string; size: number }>;

     

       18
       18
       +
       }} LiveCheckInfo */

     

       19
       19
       +
       

     

       20
       20
       +
       /** @typedef {{

     

       21
       21
       +
         version: string;

     

       22
       22
       +
         url: string;

     

       23
       23
       +
         hash: `sha512-${string}`;

     

       24
       24
       +
       }} Info */

     

       25
       25
       +
       

     

       26
       26
       +
       /** @typedef {{

     

       27
       27
       +
         "x86_64-darwin": Info;

     

       28
       28
       +
         "aarch64-darwin": Info;

     

       29
       29
       +
       }} InfoMap */

     

       30
       30
       +
       

     

       31
       31
       +
       const BASE_URL = "https://desktop-release.notion-static.com/";

     

       32
       32
       +
       /**

     

       33
       33
       +
        *

     

       34
       34
       +
        * @param {"latest-mac.yml" | "arm64-mac.yml"} liveCheckFile

     

       35
       35
       +
        * @returns {Promise<Info>}

     

       36
       36
       +
        */

     

       37
       37
       +
       async function getInfo(liveCheckFile) {

     

       38
       38
       +
         const url = /** @type {const} */ (`${BASE_URL}${liveCheckFile}`);

     

       39
       39
       +
         const response = await fetch(url);

     

       40
       40
       +
         assert.ok(response.ok, `Failed to fetch ${url}`);

     

       41
       41
       +
         /** @type {LiveCheckInfo} */

     

       42
       42
       +
         const { version, path, sha512 } = JSON.parse(

     

       43
       43
       +
           child_process

     

       44
       44
       +
             .execSync(`yq eval --output-format=json`, {

     

       45
       45
       +
               input: Buffer.from(await response.arrayBuffer()),

     

       46
       46
       +
             })

     

       47
       47
       +
             .toString()

     

       48
       48
       +
         );

     

       49
       49
       +
         assert.ok(version, "version is required");

     

       50
       50
       +
         assert.ok(path, "path is required");

     

       51
       51
       +
         assert.ok(sha512, "sha512 is required");

     

       52
       52
       +
         return {

     

       53
       53
       +
           version,

     

       54
       54
       +
           url: BASE_URL + path,

     

       55
       55
       +
           hash: `sha512-${sha512}`,

     

       56
       56
       +
         };

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       async function main() {

     

       60
       60
       +
         const filePath = path.join(__dirname, "../info.json");

     

       61
       61
       +
         /** @type {InfoMap} */

     

       62
       62
       +
         const oldInfo = JSON.parse(

     

       63
       63
       +
           await fsPromises.readFile(filePath, { encoding: "utf-8" })

     

       64
       64
       +
         );

     

       65
       65
       +
         /** @type {InfoMap} */

     

       66
       66
       +
         const info = {

     

       67
       67
       +
           "x86_64-darwin": await getInfo("latest-mac.yml"),

     

       68
       68
       +
           "aarch64-darwin": await getInfo("arm64-mac.yml"),

     

       69
       69
       +
         };

     

       70
       70
       +
         if (JSON.stringify(oldInfo) === JSON.stringify(info)) {

     

       71
       71
       +
           console.log("[update] No updates found");

     

       72
       72
       +
           return;

     

       73
       73
       +
         }

     

       74
       74
       +
         const platforms = /** @type {const} */ (["x86_64-darwin", "aarch64-darwin"]);

     

       75
       75
       +
         for (const platform of platforms) {

     

       76
       76
       +
           console.log(

     

       77
       77
       +
             `[update] Updating Notion ${platform} ${oldInfo[platform].version} -> ${info[platform].version}`

     

       78
       78
       +
           );

     

       79
       79
       +
         }

     

       80
       80
       +
         await fsPromises.writeFile(

     

       81
       81
       +
           filePath,

     

       82
       82
       +
           JSON.stringify(info, null, 2) + "\n",

     

       83
       83
       +
           "utf-8"

     

       84
       84
       +
         );

     

       85
       85
       +
         console.log("[update] Updating Notion complete");

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       main();

+2 -2

pkgs/by-name/oq/oqs-provider/package.nix

···

       9
       9
        
       }:

     

       10
       10
        
       stdenv.mkDerivation (finalAttrs: {

     

       11
       11
        
         name = "oqs-provider";

     

       12
       12
       -
         version = "0.7.0";

     

       12
       12
       +
         version = "0.8.0";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "open-quantum-safe";

     

       16
       16
        
           repo = "oqs-provider";

     

       17
       17
        
           rev = finalAttrs.version;

     

       18
       18
       -
           hash = "sha256-v7YIE5uzBvQHfi2hqkkRrW0F3K4haZyuoKHxAtRqQDA=";

     

       18
       18
       +
           hash = "sha256-P3UEiWYchHVQ5s3JXHOzaDaN09K62pMYjnrW/gS5x/I=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         nativeBuildInputs = [

+1 -1

pkgs/by-name/po/posy-cursors/package.nix

···

       26
       26
        
           description = "Posy's Improved Cursors for Linux";

     

       27
       27
        
           homepage = "https://github.com/simtrami/posy-improved-cursor-linux";

     

       28
       28
        
           platforms = platforms.unix;

     

       29
       29
       -
           license = licenses.unfree;

     

       29
       29
       +
           license = licenses.cc-by-nc-40;

     

       30
       30
        
           maintainers = with maintainers; [ mkez ];

     

       31
       31
        
         };

     

       32
       32
        
       }

+2 -2

pkgs/by-name/qu/quickemu/package.nix

···

       13
       13
        
         pciutils,

     

       14
       14
        
         procps,

     

       15
       15
        
         python3,

     

       16
       16
       -
         qemu_full,

     

       16
       16
       +
         qemu,

     

       17
       17
        
         socat,

     

       18
       18
        
         spice-gtk,

     

       19
       19
        
         swtpm,

     
···

       40
       40
        
             pciutils

     

       41
       41
        
             procps

     

       42
       42
        
             python3

     

       43
       43
       -
             qemu_full

     

       43
       43
       +
             (qemu.override { smbdSupport = true; })

     

       44
       44
        
             socat

     

       45
       45
        
             swtpm

     

       46
       46
        
             util-linux

+1 -1

pkgs/by-name/se/senpai/package.nix

···

       42
       42
        
         meta = with lib; {

     

       43
       43
        
           description = "Your everyday IRC student";

     

       44
       44
        
           mainProgram = "senpai";

     

       45
       45
       -
           homepage = "https://sr.ht/~taiite/senpai/";

     

       45
       45
       +
           homepage = "https://sr.ht/~delthas/senpai/";

     

       46
       46
        
           changelog = "https://git.sr.ht/~delthas/senpai/refs/v${version}";

     

       47
       47
        
           license = licenses.isc;

     

       48
       48
        
           maintainers = with maintainers; [ malte-v ];

+2 -2

pkgs/by-name/tr/trealla/package.nix

···

       23
       23
        
       ];

     

       24
       24
        
       stdenv.mkDerivation (finalAttrs: {

     

       25
       25
        
         pname = "trealla";

     

       26
       26
       -
         version = "2.63.10";

     

       26
       26
       +
         version = "2.63.11";

     

       27
       27
        
       

     

       28
       28
        
         src = fetchFromGitHub {

     

       29
       29
        
           owner = "trealla-prolog";

     

       30
       30
        
           repo = "trealla";

     

       31
       31
        
           rev = "v${finalAttrs.version}";

     

       32
       32
       -
           hash = "sha256-LGikCupqzUZ2CG63c8aEeJHX+8nNMUaaYzAGQC+YHqM=";

     

       32
       32
       +
           hash = "sha256-3Z8LML2BTHAaNEg65YqYg0HyLNG1HwHpztGfSY1VGyw=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         postPatch = ''

+4 -4

pkgs/by-name/ts/tsukimi/package.nix

···

       15
       15
        
       }:

     

       16
       16
        
       rustPlatform.buildRustPackage rec {

     

       17
       17
        
         pname = "tsukimi";

     

       18
       18
       -
         version = "0.18.0";

     

       18
       18
       +
         version = "0.18.1";

     

       19
       19
        
       

     

       20
       20
        
         src = fetchFromGitHub {

     

       21
       21
        
           owner = "tsukinaha";

     

       22
       22
        
           repo = "tsukimi";

     

       23
       23
       -
           rev = "v${version}";

     

       24
       24
       -
           hash = "sha256-JHB1D94ymVjP3PEHZ4fTT4c6VOEkFgSdpanzs1AzJUc=";

     

       23
       23
       +
           tag = "v${version}";

     

       24
       24
       +
           hash = "sha256-S4+mhFgBNSl2h8dk0izNyCw9//u3CaLGd/shCSWmN3M=";

     

       25
       25
        
           fetchSubmodules = true;

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         useFetchCargoVendor = true;

     

       29
       29
       -
         cargoHash = "sha256-Gh9CPQ73+EpwZTixgQpV4rSwZnedVHQwZRlLQXr8EUo=";

     

       29
       29
       +
         cargoHash = "sha256-zVzDpZRni/0AyGE5ahBH7hm8Ovyt+Fn6x1NOHkyI0v8=";

     

       30
       30
        
       

     

       31
       31
        
         nativeBuildInputs = [

     

       32
       32
        
           pkg-config

+9 -7

pkgs/by-name/us/usbkvm/package.nix

···

       11
       11
        
         pkg-config,

     

       12
       12
        
         python3,

     

       13
       13
        
         stdenv,

     

       14
       14
       +
         udev,

     

       14
       15
        
         wrapGAppsHook3,

     

       15
       16
        
       }:

     

       16
       17
        
       

     

       17
       18
        
       let

     

       18
       18
       -
         version = "0.1.0";

     

       19
       19
       +
         version = "0.2.0";

     

       19
       20
        
       

     

       20
       21
        
         src = fetchzip {

     

       21
       22
        
           url = "https://github.com/carrotIndustries/usbkvm/releases/download/v${version}/usbkvm-v${version}.tar.gz";

     

       22
       22
       -
           sha256 = "sha256-OuZ7+IjsvK7/PaiTRwssaQFJDFWJ8HX+kqV13CUyTZA=";

     

       23
       23
       +
           sha256 = "sha256-ng6YpaN7sKEBPJcJAm0kcYtT++orweWRx6uOZFnOGG8=";

     

       23
       24
        
         };

     

       24
       25
        
       

     

       25
       26
        
         ms-tools-lib = buildGoModule {

     
···

       51
       52
        
           ninja

     

       52
       53
        
           makeWrapper

     

       53
       54
        
           wrapGAppsHook3

     

       55
       55
       +
           udev

     

       54
       56
        
         ];

     

       55
       57
        
       

     

       56
       58
        
         buildInputs = [

     
···

       71
       73
        
             --replace-fail "@MSLIB_H_PRECOMPILED@" "${ms-tools-lib}/mslib.h"

     

       72
       74
        
         '';

     

       73
       75
        
       

     

       76
       76
       +
         # Install udev rules in this package's out path:

     

       77
       77
       +
         mesonFlags = [

     

       78
       78
       +
           "-Dudevrulesdir=lib/udev/rules.d"

     

       79
       79
       +
         ];

     

       80
       80
       +
       

     

       74
       81
        
         postFixup =

     

       75
       82
        
           let

     

       76
       83
        
             GST_PLUGIN_PATH = lib.makeSearchPathOutput "lib" "lib/gstreamer-1.0" [

     
···

       82
       89
        
             wrapProgram $out/bin/usbkvm \

     

       83
       90
        
               --prefix GST_PLUGIN_PATH : "${GST_PLUGIN_PATH}"

     

       84
       91
        
           '';

     

       85
       85
       -
       

     

       86
       86
       -
         postInstall = ''

     

       87
       87
       -
           mkdir -p $out/lib/udev/rules.d/

     

       88
       88
       -
           cp ../70-usbkvm.rules $out/lib/udev/rules.d/

     

       89
       89
       -
         '';

     

       90
       92
        
       

     

       91
       93
        
         meta = {

     

       92
       94
        
           homepage = "https://github.com/carrotIndustries/usbkvm";

+5 -3

pkgs/by-name/wa/walker/package.nix

···

       3
       3
        
         buildGoModule,

     

       4
       4
        
         fetchFromGitHub,

     

       5
       5
        
         pkg-config,

     

       6
       6
       +
         vips,

     

       6
       7
        
         gobject-introspection,

     

       7
       8
        
         wrapGAppsHook4,

     

       8
       9
        
         gtk4,

     
···

       12
       13
        
       

     

       13
       14
        
       buildGoModule rec {

     

       14
       15
        
         pname = "walker";

     

       15
       15
       -
         version = "0.9.0";

     

       16
       16
       +
         version = "0.11.16";

     

       16
       17
        
       

     

       17
       18
        
         src = fetchFromGitHub {

     

       18
       19
        
           owner = "abenz1267";

     

       19
       20
        
           repo = "walker";

     

       20
       21
        
           rev = "v${version}";

     

       21
       21
       -
           hash = "sha256-nYC6KoLsmMf6uJ74Y2zvDU5wdgeOU9aZb/4zGlnWOJM=";

     

       22
       22
       +
           hash = "sha256-9cZ+cJcBiZA0HU8YU7+DmOPmbeFtuiqmyBEosVxCADQ=";

     

       22
       23
        
         };

     

       23
       24
        
       

     

       24
       24
       -
         vendorHash = "sha256-nc/WKBhUxhs1aNUg/GM7vhrKd7FrUdl2uKp7MX2VCdE=";

     

       25
       25
       +
         vendorHash = "sha256-urAtl2aSuNw7UVnuacSACUE8PCwAsrRQbuMb7xItjao=";

     

       25
       26
        
         subPackages = [ "cmd/walker.go" ];

     

       26
       27
        
       

     

       27
       28
        
         passthru.updateScript = nix-update-script { };

     
···

       34
       35
        
       

     

       35
       36
        
         buildInputs = [

     

       36
       37
        
           gtk4

     

       38
       38
       +
           vips

     

       37
       39
        
           gtk4-layer-shell

     

       38
       40
        
         ];

     

       39
       41

+60

pkgs/by-name/xr/xrizer/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         fetchFromGitHub,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         libxkbcommon,

     

       5
       5
       +
         nix-update-script,

     

       6
       6
       +
         openxr-loader,

     

       7
       7
       +
         pkg-config,

     

       8
       8
       +
         rustPlatform,

     

       9
       9
       +
         shaderc,

     

       10
       10
       +
         vulkan-loader,

     

       11
       11
       +
       }:

     

       12
       12
       +
       rustPlatform.buildRustPackage rec {

     

       13
       13
       +
         pname = "xrizer";

     

       14
       14
       +
         version = "0.1";

     

       15
       15
       +
       

     

       16
       16
       +
         src = fetchFromGitHub {

     

       17
       17
       +
           owner = "Supreeeme";

     

       18
       18
       +
           repo = "xrizer";

     

       19
       19
       +
           tag = "v${version}";

     

       20
       20
       +
           hash = "sha256-0szkc/EURm4N0gl+tSFhLeQTYPX7ZgBHXwpP11Ju8Ng=";

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         useFetchCargoVendor = true;

     

       24
       24
       +
         cargoHash = "sha256-xyiEKPnko9mpEsUfl7wuAAsobRTwBHhZuKuU/HP4Ujs=";

     

       25
       25
       +
       

     

       26
       26
       +
         nativeBuildInputs = [

     

       27
       27
       +
           pkg-config

     

       28
       28
       +
           rustPlatform.bindgenHook

     

       29
       29
       +
           shaderc

     

       30
       30
       +
         ];

     

       31
       31
       +
       

     

       32
       32
       +
         buildInputs = [

     

       33
       33
       +
           libxkbcommon

     

       34
       34
       +
           vulkan-loader

     

       35
       35
       +
           openxr-loader

     

       36
       36
       +
         ];

     

       37
       37
       +
       

     

       38
       38
       +
         postPatch = ''

     

       39
       39
       +
           substituteInPlace Cargo.toml \

     

       40
       40
       +
             --replace-fail 'features = ["static"]' 'features = ["linked"]'

     

       41
       41
       +
         '';

     

       42
       42
       +
       

     

       43
       43
       +
         postInstall = ''

     

       44
       44
       +
           mkdir -p $out/lib/xrizer/bin/linux64

     

       45
       45
       +
           ln -s "$out/lib/libxrizer.so" "$out/lib/xrizer/bin/linux64/vrclient.so"

     

       46
       46
       +
         '';

     

       47
       47
       +
       

     

       48
       48
       +
         passthru.updateScript = nix-update-script { };

     

       49
       49
       +
       

     

       50
       50
       +
         meta = {

     

       51
       51
       +
           description = "XR-ize your favorite OpenVR games";

     

       52
       52
       +
           homepage = "https://github.com/Supreeeme/xrizer";

     

       53
       53
       +
           license = lib.licenses.gpl3Only;

     

       54
       54
       +
           maintainers = with lib.maintainers; [ Scrumplex ];

     

       55
       55
       +
           # TODO: support more systems

     

       56
       56
       +
           # To do so, we need to map systems to the format openvr expects.

     

       57
       57
       +
           # i.e. x86_64-linux -> linux64, aarch64-linux -> linuxarm64

     

       58
       58
       +
           platforms = [ "x86_64-linux" ];

     

       59
       59
       +
         };

     

       60
       60
       +
       }

+6 -6

pkgs/development/compilers/scala/2.x.nix

···

       21
       21
        
         versionMap = {

     

       22
       22
        
           "2.10" = {

     

       23
       23
        
             version = "2.10.7";

     

       24
       24
       -
             sha256 = "koMRmRb2u3cU4HaihAzPItWIGbNVIo7RWRrm92kp8RE=";

     

       24
       24
       +
             hash = "sha256-koMRmRb2u3cU4HaihAzPItWIGbNVIo7RWRrm92kp8RE=";

     

       25
       25
        
             pname = "scala_2_10";

     

       26
       26
        
           };

     

       27
       27
        
       

     

       28
       28
        
           "2.11" = {

     

       29
       29
        
             version = "2.11.12";

     

       30
       30
       -
             sha256 = "sR19M2mcpPYLw7K2hY/ZU+PeK4UiyUP0zaS2dDFhlqg=";

     

       30
       30
       +
             hash = "sha256-sR19M2mcpPYLw7K2hY/ZU+PeK4UiyUP0zaS2dDFhlqg=";

     

       31
       31
        
             pname = "scala_2_11";

     

       32
       32
        
           };

     

       33
       33
        
       

     

       34
       34
        
           "2.12" = {

     

       35
       35
        
             version = "2.12.18";

     

       36
       36
       -
             sha256 = "naIJCET+YPrbXln39F9aU3DBdnjcn7PYMmhDxETOA5g=";

     

       36
       36
       +
             hash = "sha256-naIJCET+YPrbXln39F9aU3DBdnjcn7PYMmhDxETOA5g=";

     

       37
       37
        
             pname = "scala_2_12";

     

       38
       38
        
           };

     

       39
       39
        
       

     

       40
       40
        
           "2.13" = {

     

       41
       41
       -
             version = "2.13.12";

     

       42
       42
       -
             sha256 = "r+fm+1njyIRX6Z9wGHMOUvuifI0V49cVT3KWggbKhxk=";

     

       41
       41
       +
             version = "2.13.15";

     

       42
       42
       +
             hash = "sha256-jXIZ0q2IHIHPdwmp5JU05s4S0Bft4Uc+r9Hpuyh8ObE=";

     

       43
       43
        
             pname = "scala_2_13";

     

       44
       44
        
           };

     

       45
       45
        
         };

     
···

       53
       53
        
         name = "scala-${version}";

     

       54
       54
        
       

     

       55
       55
        
         src = fetchurl {

     

       56
       56
       -
           inherit sha256;

     

       56
       56
       +
           inherit hash;

     

       57
       57
        
           url = "https://www.scala-lang.org/files/archive/scala-${version}.tgz";

     

       58
       58
        
         };

     

       59
       59

+12 -11

pkgs/development/coq-modules/smtcoq/default.nix

···

       11
       11
        
         version ? null,

     

       12
       12
        
       }:

     

       13
       13
        
       

     

       14
       14
       -
       let

     

       15
       15
       -
         # version of veriT that works with SMTCoq

     

       16
       16
       -
         veriT' = veriT.overrideAttrs (oA: {

     

       17
       17
       -
           src = fetchurl {

     

       18
       18
       -
             url = "https://www.lri.fr/~keller/Documents-recherche/Smtcoq/veriT9f48a98.tar.gz";

     

       19
       19
       -
             sha256 = "sha256-Pe46PxQVHWwWwx5Ei4Bl95A0otCiXZuUZ2nXuZPYnhY=";

     

       20
       20
       -
           };

     

       21
       21
       -
           meta.broken = false;

     

       22
       22
       -
         });

     

       23
       23
       -
       in

     

       14
       14
       +
       # Broken since https://github.com/NixOS/nixpkgs/pull/354627, temporarily disactivated

     

       15
       15
       +
       # let

     

       16
       16
       +
       #   # version of veriT that works with SMTCoq

     

       17
       17
       +
       #   veriT' = veriT.overrideAttrs (oA: {

     

       18
       18
       +
       #     src = fetchurl {

     

       19
       19
       +
       #       url = "https://www.lri.fr/~keller/Documents-recherche/Smtcoq/veriT9f48a98.tar.gz";

     

       20
       20
       +
       #       sha256 = "sha256-Pe46PxQVHWwWwx5Ei4Bl95A0otCiXZuUZ2nXuZPYnhY=";

     

       21
       21
       +
       #     };

     

       22
       22
       +
       #     meta.broken = false;

     

       23
       23
       +
       #   });

     

       24
       24
       +
       # in

     

       24
       25
        
       

     

       25
       26
        
       mkCoqDerivation {

     

       26
       27
        
         pname = "smtcoq";

     
···

       79
       80
        
         propagatedBuildInputs =

     

       80
       81
        
           [

     

       81
       82
        
             cvc5

     

       82
       82
       -
             veriT'

     

       83
       83
       +
             # veriT'  # c.f. comment above

     

       83
       84
        
             zchaff

     

       84
       85
        
             stdlib

     

       85
       86
        
           ]

-48

pkgs/development/libraries/botan/botan3-macos.patch

···

       1
       1
       -
       diff --git a/src/lib/prov/commoncrypto/commoncrypto_block.cpp b/src/lib/prov/commoncrypto/commoncrypto_block.cpp

     

       2
       2
       -
       index a07fe118d..f059ee497 100644

     

       3
       3
       -
       --- a/src/lib/prov/commoncrypto/commoncrypto_block.cpp

     

       4
       4
       -
       +++ b/src/lib/prov/commoncrypto/commoncrypto_block.cpp

     

       5
       5
       -
       @@ -11,6 +11,7 @@

     

       6
       6
       -
        #include <botan/hex.h>

     

       7
       7
       -
        #include <botan/internal/commoncrypto_utils.h>

     

       8
       8
       -
        

     

       9
       9
       -
       +#include <CommonCrypto/CommonCryptoError.h>

     

       10
       10
       -
        #include <CommonCrypto/CommonCrypto.h>

     

       11
       11
       -
        

     

       12
       12
       -
        namespace Botan {

     

       13
       13
       -
       diff --git a/src/lib/prov/commoncrypto/commoncrypto_hash.cpp b/src/lib/prov/commoncrypto/commoncrypto_hash.cpp

     

       14
       14
       -
       index 1fb79c419..faf9575c2 100644

     

       15
       15
       -
       --- a/src/lib/prov/commoncrypto/commoncrypto_hash.cpp

     

       16
       16
       -
       +++ b/src/lib/prov/commoncrypto/commoncrypto_hash.cpp

     

       17
       17
       -
       @@ -11,6 +11,7 @@

     

       18
       18
       -
        #include <botan/internal/stl_util.h>

     

       19
       19
       -
        #include <unordered_map>

     

       20
       20
       -
        

     

       21
       21
       -
       +#include <CommonCrypto/CommonCryptoError.h>

     

       22
       22
       -
        #include <CommonCrypto/CommonCrypto.h>

     

       23
       23
       -
        

     

       24
       24
       -
        namespace Botan {

     

       25
       25
       -
       diff --git a/src/lib/prov/commoncrypto/commoncrypto_utils.h b/src/lib/prov/commoncrypto/commoncrypto_utils.h

     

       26
       26
       -
       index b1c7411fd..9becab2d1 100644

     

       27
       27
       -
       --- a/src/lib/prov/commoncrypto/commoncrypto_utils.h

     

       28
       28
       -
       +++ b/src/lib/prov/commoncrypto/commoncrypto_utils.h

     

       29
       29
       -
       @@ -10,6 +10,7 @@

     

       30
       30
       -
        

     

       31
       31
       -
        #include <botan/sym_algo.h>

     

       32
       32
       -
        

     

       33
       33
       -
       +#include <CommonCrypto/CommonCryptoError.h>

     

       34
       34
       -
        #include <CommonCrypto/CommonCrypto.h>

     

       35
       35
       -
        

     

       36
       36
       -
        namespace Botan {

     

       37
       37
       -
       diff --git a/src/lib/rng/system_rng/system_rng.cpp b/src/lib/rng/system_rng/system_rng.cpp

     

       38
       38
       -
       index b2f7b4c45..f4933b1e3 100644

     

       39
       39
       -
       --- a/src/lib/rng/system_rng/system_rng.cpp

     

       40
       40
       -
       +++ b/src/lib/rng/system_rng/system_rng.cpp

     

       41
       41
       -
       @@ -20,6 +20,7 @@

     

       42
       42
       -
           #include <bcrypt.h>

     

       43
       43
       -
           #include <windows.h>

     

       44
       44
       -
        #elif defined(BOTAN_TARGET_OS_HAS_CCRANDOM)

     

       45
       45
       -
       +   #include <CommonCrypto/CommonCryptoError.h>

     

       46
       46
       -
           #include <CommonCrypto/CommonRandom.h>

     

       47
       47
       -
        #elif defined(BOTAN_TARGET_OS_HAS_ARC4RANDOM)

     

       48
       48
       -
           #include <stdlib.h>

-2

pkgs/development/libraries/botan/default.nix

···

       124
       124
        
         botan3 = common {

     

       125
       125
        
           version = "3.6.1";

     

       126
       126
        
           hash = "sha256-fLhXXYjSMsdxdHadf54ku0REQWBYWYbuvWbnScuakIk=";

     

       127
       127
       -
           # this patch fixes build errors on MacOS with SDK 10.12, recheck to remove this again

     

       128
       128
       -
           patches = lib.optionals stdenv.hostPlatform.isDarwin [ ./botan3-macos.patch ];

     

       129
       127
        
         };

     

       130
       128
        
       

     

       131
       129
        
         botan2 = common {

+38

pkgs/development/ocaml-modules/mlx/ocamlmerlin-mlx.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         mlx,

     

       4
       4
       +
         buildDunePackage,

     

       5
       5
       +
         ppxlib,

     

       6
       6
       +
         merlin-lib,

     

       7
       7
       +
         cppo,

     

       8
       8
       +
         csexp,

     

       9
       9
       +
         menhir,

     

       10
       10
       +
         odoc,

     

       11
       11
       +
       }:

     

       12
       12
       +
       buildDunePackage {

     

       13
       13
       +
         pname = "ocamlmerlin-mlx";

     

       14
       14
       +
       

     

       15
       15
       +
         inherit (mlx) version src;

     

       16
       16
       +
       

     

       17
       17
       +
         minimalOCamlVersion = "4.14";

     

       18
       18
       +
       

     

       19
       19
       +
         buildInputs = [

     

       20
       20
       +
           ppxlib

     

       21
       21
       +
           merlin-lib

     

       22
       22
       +
           csexp

     

       23
       23
       +
           menhir

     

       24
       24
       +
           odoc

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         nativeBuildInputs = [

     

       28
       28
       +
           cppo

     

       29
       29
       +
         ];

     

       30
       30
       +
       

     

       31
       31
       +
         meta = {

     

       32
       32
       +
           description = "Merlin support for MLX OCaml dialect";

     

       33
       33
       +
           homepage = "https://github.com/ocaml-mlx/mlx";

     

       34
       34
       +
           license = lib.licenses.mit;

     

       35
       35
       +
           maintainers = [ lib.maintainers.Denommus ];

     

       36
       36
       +
           mainProgram = "ocamlmerlin-mlx";

     

       37
       37
       +
         };

     

       38
       38
       +
       }

+2 -2

pkgs/development/ocaml-modules/odds/default.nix

···

       9
       9
        
         pname = "odds";

     

       10
       10
        
         version = "1.2";

     

       11
       11
        
       

     

       12
       12
       -
         minimalOcamlVersion = "5.0.0";

     

       12
       12
       +
         minimalOCamlVersion = "5.0.0";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "raphael-proust";

     
···

       18
       18
        
           hash = "sha256-tPDowkpsJQKCoeuXOb9zPORoudUvkRBZ3OzkH2QE2zg=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
       -
         propagatedBuildInputs = [

     

       21
       21
       +
         buildInputs = [

     

       22
       22
        
           cmdliner

     

       23
       23
        
         ];

     

       24
       24

+2 -2

pkgs/development/octave-modules/matgeom/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildOctavePackage rec {

     

       8
       8
        
         pname = "matgeom";

     

       9
       9
       -
         version = "1.2.3";

     

       9
       9
       +
         version = "1.2.4";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchurl {

     

       12
       12
        
           url = "mirror://sourceforge/octave/${pname}-${version}.tar.gz";

     

       13
       13
       -
           sha256 = "12q66dy4ninhki3jslzcamfblcb3cdkfbbzn3a5har1s212lsfiw";

     

       13
       13
       +
           sha256 = "sha256-azRPhwMVvydCyojA/rXD2og1tPTL0vii15OveYQF+SA=";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

+2 -2

pkgs/development/python-modules/adafruit-platformdetect/default.nix

···

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
        
         pname = "adafruit-platformdetect";

     

       11
       11
       -
         version = "3.75.0";

     

       11
       11
       +
         version = "3.76.1";

     

       12
       12
        
         pyproject = true;

     

       13
       13
        
       

     

       14
       14
        
         disabled = pythonOlder "3.7";

     
···

       16
       16
        
         src = fetchPypi {

     

       17
       17
        
           pname = "adafruit_platformdetect";

     

       18
       18
        
           inherit version;

     

       19
       19
       -
           hash = "sha256-5Awvnzw0tgZhRXVshTOuzerdORJ+5QCH3PDB7pbjCB0=";

     

       19
       19
       +
           hash = "sha256-xFoqymbYEs7L7bP0/psCz44SZO7yCbMArm9GfLo25Lg=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         build-system = [ setuptools-scm ];

+2 -2

pkgs/development/python-modules/aranet4/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildPythonPackage rec {

     

       13
       13
        
         pname = "aranet4";

     

       14
       14
       -
         version = "2.4.0";

     

       14
       14
       +
         version = "2.5.0";

     

       15
       15
        
         pyproject = true;

     

       16
       16
        
       

     

       17
       17
        
         disabled = pythonOlder "3.7";

     
···

       20
       20
        
           owner = "Anrijs";

     

       21
       21
        
           repo = "Aranet4-Python";

     

       22
       22
        
           tag = "v${version}";

     

       23
       23
       -
           hash = "sha256-PdEOEVHri9bhsRFtSqZIaTJ7perD6nZcYoF2sDrWXqg=";

     

       23
       23
       +
           hash = "sha256-IDMWRFxasmZ5pmd36cgss8vV0eVOIzu08dfJHVT+QUQ=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         build-system = [ setuptools ];

+2 -2

pkgs/development/python-modules/pynmeagps/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "pynmeagps";

     

       13
       13
       -
         version = "1.0.43";

     

       13
       13
       +
         version = "1.0.44";

     

       14
       14
        
         pyproject = true;

     

       15
       15
        
       

     

       16
       16
        
         disabled = pythonOlder "3.9";

     
···

       19
       19
        
           owner = "semuconsulting";

     

       20
       20
        
           repo = "pynmeagps";

     

       21
       21
        
           tag = "v${version}";

     

       22
       22
       -
           hash = "sha256-U5AI6iQiMvlCfL0SMAl0PkwC/orCr57royWvHKvWpAI=";

     

       22
       22
       +
           hash = "sha256-AnLQJueJYhoOzTjC1hKyo4UFL//pDyKETvLNA4pKp7A=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         build-system = [ setuptools ];

+2 -2

pkgs/development/python-modules/tencentcloud-sdk-python/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "tencentcloud-sdk-python";

     

       13
       13
       -
         version = "3.0.1295";

     

       13
       13
       +
         version = "3.0.1296";

     

       14
       14
        
         pyproject = true;

     

       15
       15
        
       

     

       16
       16
        
         disabled = pythonOlder "3.9";

     
···

       19
       19
        
           owner = "TencentCloud";

     

       20
       20
        
           repo = "tencentcloud-sdk-python";

     

       21
       21
        
           tag = version;

     

       22
       22
       -
           hash = "sha256-mbrOk+aeeVCfNHCMvU9p1/P3X1Z+n8XIsNfKnOOZ0Q4=";

     

       22
       22
       +
           hash = "sha256-iTcI/pNCcQamVuDYIjv60KR4CBwBRVwZJ+VAJqR1keM=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         build-system = [ setuptools ];

+1 -1

pkgs/development/tools/haskell/ihaskell/wrapper.nix

···

       22
       22
        
         );

     

       23
       23
        
         ihaskellSh = writeScriptBin "ihaskell-notebook" ''

     

       24
       24
        
           #! ${stdenv.shell}

     

       25
       25
       -
           export GHC_PACKAGE_PATH="$(echo ${ihaskellEnv}/lib/*/package.conf.d| tr ' ' ':'):$GHC_PACKAGE_PATH"

     

       25
       25
       +
           export GHC_PACKAGE_PATH="$(${ihaskellEnv}/bin/ghc --print-global-package-db):$GHC_PACKAGE_PATH"

     

       26
       26
        
           export PATH="${

     

       27
       27
        
             lib.makeBinPath ([

     

       28
       28
        
               ihaskellEnv

+2 -2

pkgs/development/tools/pnpm/default.nix

···

       12
       12
        
             hash = "sha256-2qJ6C1QbxjUyP/lsLe2ZVGf/n+bWn/ZwIVWKqa2dzDY=";

     

       13
       13
        
           };

     

       14
       14
        
           "9" = {

     

       15
       15
       -
             version = "9.15.2";

     

       16
       16
       -
             hash = "sha256-AiMJuzE1kUK2W/qIngQG0u69Ws//ykfmlErPKdnWpms=";

     

       15
       15
       +
             version = "9.15.3";

     

       16
       16
       +
             hash = "sha256-wdpDcnzLwe1Cr/T9a9tLHpHmWoGObv/1skD78HC6Tq8=";

     

       17
       17
        
           };

     

       18
       18
        
         };

     

       19
       19

+2 -2

pkgs/misc/tmux-plugins/default.nix

···

       197
       197
        
       

     

       198
       198
        
         dracula = mkTmuxPlugin rec {

     

       199
       199
        
           pluginName = "dracula";

     

       200
       200
       -
           version = "2.3.0";

     

       200
       200
       +
           version = "3.0.0";

     

       201
       201
        
           src = fetchFromGitHub {

     

       202
       202
        
             owner = "dracula";

     

       203
       203
        
             repo = "tmux";

     

       204
       204
        
             rev = "v${version}";

     

       205
       205
       -
             sha256 = "IrNDBRopg9lgN5AfeXbhhh+uXiWQD2bjS1sNOgOJsu4=";

     

       205
       205
       +
             hash = "sha256-VY4PyaQRwTc6LWhPJg4inrQf5K8+bp0+eqRhR7+Iexk=";

     

       206
       206
        
           };

     

       207
       207
        
           meta = with lib; {

     

       208
       208
        
             homepage = "https://draculatheme.com/tmux";

+4 -4

pkgs/os-specific/linux/kernel/xanmod-kernels.nix

···

       14
       14
        
         # kernel config in the xanmod version commit

     

       15
       15
        
         variants = {

     

       16
       16
        
           lts = {

     

       17
       17
       -
             version = "6.6.68";

     

       18
       18
       -
             hash = "sha256-fuPJgbDJ2PLB74fy/WFnhGdTEKJMeNwsbWm6RVM4Jes=";

     

       17
       17
       +
             version = "6.6.69";

     

       18
       18
       +
             hash = "sha256-ZU0vVea8CCR41Sc+bbM4GOnDsFUpTvBvCEHSHLmWHds=";

     

       19
       19
        
           };

     

       20
       20
        
           main = {

     

       21
       21
       -
             version = "6.12.7";

     

       22
       22
       -
             hash = "sha256-sM9XINKBGRcO29o3kEIKM03t/XojG9nYLirQSBii8Y4=";

     

       21
       21
       +
             version = "6.12.8";

     

       22
       22
       +
             hash = "sha256-rEzSM71ACrBclunnJZ4qaEhPGIKCvyLVpeHgsiDxMu4=";

     

       23
       23
        
           };

     

       24
       24
        
         };

     

       25
       25

+5 -2

pkgs/servers/home-assistant/custom-components/solis-sensor/package.nix

···

       3
       3
        
         fetchFromGitHub,

     

       4
       4
        
         buildHomeAssistantComponent,

     

       5
       5
        
         aiofiles,

     

       6
       6
       +
         nix-update-script,

     

       6
       7
        
       }:

     

       7
       8
        
       

     

       8
       9
        
       buildHomeAssistantComponent rec {

     

       9
       10
        
         owner = "hultenvp";

     

       10
       11
        
         domain = "solis";

     

       11
       11
       -
         version = "3.7.2";

     

       12
       12
       +
         version = "3.8.0";

     

       12
       13
        
       

     

       13
       14
        
         src = fetchFromGitHub {

     

       14
       15
        
           owner = "hultenvp";

     

       15
       16
        
           repo = "solis-sensor";

     

       16
       17
        
           rev = "v${version}";

     

       17
       17
       -
           hash = "sha256-8+KzZCfBYvXO73SrMXLGCUjecxKn49hz0wCXWCUBULU=";

     

       18
       18
       +
           hash = "sha256-lExwqJj70iNzjZyTw5udcWx6FB95aqZh7cYtXHWMHK0=";

     

       18
       19
        
         };

     

       19
       20
        
       

     

       20
       21
        
         dependencies = [ aiofiles ];

     

       21
       22
        
       

     

       22
       23
        
         dontCheckManifest = true; # aiofiles version constraint mismatch

     

       24
       24
       +
       

     

       25
       25
       +
         passthru.updateScript = nix-update-script { };

     

       23
       26
        
       

     

       24
       27
        
         meta = with lib; {

     

       25
       28
        
           description = "Home Assistant integration for the SolisCloud PV Monitoring portal via SolisCloud API";

+1 -1

pkgs/tools/security/metasploit/Gemfile

···

       1
       1
        
       # frozen_string_literal: true

     

       2
       2
        
       source "https://rubygems.org"

     

       3
       3
        
       

     

       4
       4
       -
       gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.4.42"

     

       4
       4
       +
       gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.4.43"

+3 -3

pkgs/tools/security/metasploit/Gemfile.lock

···

       1
       1
        
       GIT

     

       2
       2
        
         remote: https://github.com/rapid7/metasploit-framework

     

       3
       3
       -
         revision: 02397587c3a571a685c43226719c77b3194837cd

     

       4
       4
       -
         ref: refs/tags/6.4.42

     

       3
       3
       +
         revision: 726e819f87e3022dc90232087bf30edb0d149ba5

     

       4
       4
       +
         ref: refs/tags/6.4.43

     

       5
       5
        
         specs:

     

       6
       6
       -
           metasploit-framework (6.4.42)

     

       6
       6
       +
           metasploit-framework (6.4.43)

     

       7
       7
        
             aarch64

     

       8
       8
        
             abbrev

     

       9
       9
        
             actionpack (~> 7.0.0)

+2 -2

pkgs/tools/security/metasploit/default.nix

···

       18
       18
        
       in

     

       19
       19
        
       stdenv.mkDerivation (finalAttrs: {

     

       20
       20
        
         pname = "metasploit-framework";

     

       21
       21
       -
         version = "6.4.42";

     

       21
       21
       +
         version = "6.4.43";

     

       22
       22
        
       

     

       23
       23
        
         src = fetchFromGitHub {

     

       24
       24
        
           owner = "rapid7";

     

       25
       25
        
           repo = "metasploit-framework";

     

       26
       26
        
           tag = finalAttrs.version;

     

       27
       27
       -
           hash = "sha256-PsYA29tEhb++Uo0Mh2sAeAUfy51+x7NGNWrMYkj2rrE=";

     

       27
       27
       +
           hash = "sha256-1zUt6nInDUIY97fBJa0dQ/hD4WZ1v5LXYdPQhnYKlYw=";

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         nativeBuildInputs = [

+3 -3

pkgs/tools/security/metasploit/gemset.nix

···

       734
       734
        
           platforms = [ ];

     

       735
       735
        
           source = {

     

       736
       736
        
             fetchSubmodules = false;

     

       737
       737
       -
             rev = "02397587c3a571a685c43226719c77b3194837cd";

     

       738
       738
       -
             sha256 = "1cdfyr465k3a6m3b7ivykp5iy1bq01mqf34daazbz1a4vgdh1iiy";

     

       737
       737
       +
             rev = "726e819f87e3022dc90232087bf30edb0d149ba5";

     

       738
       738
       +
             sha256 = "134m19v8dl6kc7br5gvmcvhl7y233nnjbhdpywc44397fbm2sdfp";

     

       739
       739
        
             type = "git";

     

       740
       740
        
             url = "https://github.com/rapid7/metasploit-framework";

     

       741
       741
        
           };

     

       742
       742
       -
           version = "6.4.42";

     

       742
       742
       +
           version = "6.4.43";

     

       743
       743
        
         };

     

       744
       744
        
         metasploit-model = {

     

       745
       745
        
           groups = [ "default" ];

+3 -3

pkgs/tools/text/mdbook-mermaid/default.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         pname = "mdbook-mermaid";

     

       11
       11
       -
         version = "0.14.0";

     

       11
       11
       +
         version = "0.14.1";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "badboy";

     

       15
       15
        
           repo = pname;

     

       16
       16
        
           tag = "v${version}";

     

       17
       17
       -
           hash = "sha256-elDKxtGMLka9Ss5CNnzw32ndxTUliNUgPXp7e4KUmBo=";

     

       17
       17
       +
           hash = "sha256-hqz2zUdDZjbe3nq4YpL68XJ64qpbjANag9S2uAM5nXg=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         cargoHash = "sha256-BnbllOsidqDEfKs0pd6AzFjzo51PKm9uFSwmOGTW3ug=";

     

       20
       20
       +
         cargoHash = "sha256-KrvrmodsoAvNxjJqdKTXva32dtlKINPGHwfxcK1VDwY=";

     

       21
       21
        
       

     

       22
       22
        
         buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [

     

       23
       23
        
           CoreServices

+2

pkgs/top-level/ocaml-packages.nix

···

       1371
       1371
        
       

     

       1372
       1372
        
           ocamline = callPackage ../development/ocaml-modules/ocamline { };

     

       1373
       1373
        
       

     

       1374
       1374
       +
           ocamlmerlin-mlx = callPackage ../development/ocaml-modules/mlx/ocamlmerlin-mlx.nix { };

     

       1375
       1375
       +
       

     

       1374
       1376
        
           ocamlmod = callPackage ../development/tools/ocaml/ocamlmod { };

     

       1375
       1377
        
       

     

       1376
       1378
        
           ocamlnet = callPackage ../development/ocaml-modules/ocamlnet { };