helloadhavan/github_issues huggingface dataset:
Repository: denoland/deno
Pull request: fix(ext/net): check for TLS using undefined rather than using ReflectHas

Fixes #23537

Changed files:
filename: ext/net/02_tls.js
patch: @@ -15,7 +15,6 @@ import {
 const {
   Number,
   ObjectDefineProperty,
-  ReflectHas,
   TypeError,
 } = primordials;
 
@@ -134,10 +133,10 @@ class TlsListener extends Listener {
  * interfaces.
  */
 function hasTlsKeyPairOptions(options) {
-  return (ReflectHas(options, "cert") || ReflectHas(options, "key") ||
-    ReflectHas(options, "certFile") ||
-    ReflectHas(options, "keyFile") || ReflectHas(options, "privateKey") ||
-    ReflectHas(options, "certChain"));
+  return (options.cert !== undefined || options.key !== undefined ||
+    options.certFile !== undefined ||
+    options.keyFile !== undefined || options.privateKey !== undefined ||
+    options.certChain !== undefined);
 }
 
 /**

filename: tests/unit/serve_test.ts
patch: @@ -2889,6 +2889,37 @@ Deno.test(
   },
 );
 
+// Regression test for https://github.com/denoland/deno/issues/23537
+Deno.test(
+  { permissions: { read: true, net: true } },
+  async function httpServerUndefinedCert() {
+    const ac = new AbortController();
+    const { promise, resolve } = Promise.withResolvers<void>();
+    const hostname = "127.0.0.1";
+
+    const server = Deno.serve({
+      handler: () => new Response("Hello World"),
+      hostname,
+      port: servePort,
+      signal: ac.signal,
+      onListen: onListen(resolve),
+      onError: createOnErrorCb(ac),
+      // Undefined should be equivalent to missing
+      cert: undefined,
+      key: undefined,
+    });
+
+    await promise;
+    const resp = await fetch(`http://localhost:${servePort}/`);
+
+    const respBody = await resp.text();
+    assertEquals("Hello World", respBody);
+
+    ac.abort();
+    await server.finished;
+  },
+);
+
 Deno.test(
   { permissions: { read: true, net: true } },
   async function httpServerWithTls() {
Repository: ggml-org/llama.cpp
Pull request: tests : fix test-quantize-fns to init the CPU backend

ref https://github.com/ggml-org/llama.cpp/pull/11227#issuecomment-2709471830

Changed files:
filename: tests/test-quantize-fns.cpp
patch: @@ -120,13 +120,7 @@ int main(int argc, char * argv[]) {
     generate_data(0.0, test_data.size(), test_data.data());
     generate_data(1.0, test_data2.size(), test_data2.data());
 
-    // Initialize GGML, ensures float conversion tables are initialized
-    struct ggml_init_params ggml_params = {
-        /* .mem_size   = */ 1*1024,
-        /* .mem_buffer = */ NULL,
-        /* .no_alloc   = */ true,
-    };
-    struct ggml_context * ctx = ggml_init(ggml_params);
+    ggml_cpu_init();
 
     int num_failed = 0;
     bool failed = false;
@@ -188,7 +182,5 @@ int main(int argc, char * argv[]) {
         printf("%d tests failed\n", num_failed);
     }
 
-    ggml_free(ctx);
-
     return num_failed > 0;
 }
Repository: facebook/react
Pull request: Make enableSuspenseLayoutEffectSemantics static for www

This feature is now enabled for the OSS release and the GK has been ramped up to 80% within FB (so the next step is to make it a static flag there as well).

Changed files:
filename: packages/shared/forks/ReactFeatureFlags.www.js
patch: @@ -26,7 +26,6 @@ export const {
   enableDebugTracing,
   skipUnmountedBoundaries,
   createRootStrictEffectsByDefault,
-  enableSuspenseLayoutEffectSemantics,
   enableUseRefAccessWarning,
   disableNativeComponentFrames,
   disableSchedulerTimeoutInWorkLoop,
@@ -38,6 +37,8 @@ export const {
 // On WWW, __EXPERIMENTAL__ is used for a new modern build.
 // It's not used anywhere in production yet.
 
+export const enableSuspenseLayoutEffectSemantics = true;
+
 export const enableStrictEffects =
   __DEV__ && dynamicFeatureFlags.enableStrictEffects;
 export const debugRenderPhaseSideEffectsForStrictMode = __DEV__;
Repository: ggml-org/llama.cpp
Pull request: `sampler`: fixes trigger tokens + lazy grammars (fix typo cast from token to string)

Fixes regression introduced in https://github.com/ggml-org/llama.cpp/pull/12034 (which got trigger tokens to just be... ignored)

Likely fixes https://github.com/ggml-org/llama.cpp/issues/12256

Note: this is hard to test against, short of exposing the triggered status of lazy grammars all the way to the server API (maybe limiting to verbose mode)

Changed files:
filename: examples/server/server.cpp
patch: @@ -384,8 +384,9 @@ struct server_task {
                             SRV_DBG("Grammar trigger token: %d (`%s`)\n", token, word.c_str());
                             common_grammar_trigger trigger;
                             trigger.type = COMMON_GRAMMAR_TRIGGER_TYPE_TOKEN;
-                            trigger.value = (llama_token) token;
-                            params.sampling.grammar_triggers.push_back(trigger);
+                            trigger.value = word;
+                            trigger.token = token;
+                            params.sampling.grammar_triggers.push_back(std::move(trigger));
                         } else {
                             SRV_DBG("Grammar trigger word: `%s`\n", word.c_str());
                             params.sampling.grammar_triggers.push_back({COMMON_GRAMMAR_TRIGGER_TYPE_WORD, word});
Repository: huggingface/transformers
Pull request: [model loading] don't `gc.collect()` if only 1 shard is used

# What does this PR do?

Fixes a test-related regression introduced by #36033. Despite speeding up `from_pretrained` in general, most tests that relied on `from_pretrained` became much slower (see tests section below).

Measuring time, the entire slowdown can be traced to a [single line](https://github.com/huggingface/transformers/blob/8cb522b4190bd556ce51be04942720650b1a3e57/src/transformers/modeling_utils.py#L4900), a `gc.collect()`. This line was not added in #36033, it was moved. [Before #36033](https://github.com/huggingface/transformers/blame/7652804d237fb8768f0f0b8129a05e4f0576114b/src/transformers/modeling_utils.py#L5060), if the checkpoint was not sharded, a `state_dict` would have been passed to `_load_pretrained_model`, and the `gc.collect()` branch would not be reached.

This PR adds a tiny `if` to skip `gc.collect()` if the checkpoint is not sharded. Since many tests rely on unsharded `from_pretrained`, we can immediately observe faster tests.

### Tests 

`py.test tests/models/gpt2/test_modeling_gpt2.py` times, which includes a mix of tests with and without `from_pretrained`, on my machine:
- commit before #36033: 25.41s
- `main`: 61.14s
- this PR:  21.78s 💪 (this means #36033 resulted in 15%+ test speedup, after this fix)




Changed files:
filename: src/transformers/modeling_utils.py
patch: @@ -4831,6 +4831,7 @@ def _load_pretrained_model(
 
         error_msgs = []
         mismatched_keys = []
+        has_multiple_shards = len(checkpoint_files) > 1
         # Iterate on all the shards to load the weights
         for shard_file in checkpoint_files:
             # Skip the load for shards that only contain disk-offloaded weights
@@ -4849,7 +4850,7 @@ def _load_pretrained_model(
                 ):
                     map_location = torch.device([d for d in device_map.values() if d not in ["cpu", "disk"]][0])
 
-            # If shard_file is""", we use the existing state_dict instead of loading it
+            # If shard_file is "", we use the existing state_dict instead of loading it
             if shard_file != "":
                 state_dict = load_state_dict(
                     shard_file, is_quantized=is_quantized, map_location=map_location, weights_only=weights_only
@@ -4895,9 +4896,10 @@ def _load_pretrained_model(
                 else:
                     model_to_load.load_state_dict(state_dict, strict=False, assign=assign_params)
 
-            # force memory release
             del state_dict
-            gc.collect()
+            # force memory release if loading multiple shards
+            if has_multiple_shards:
+                gc.collect()
 
         # Adjust offloaded weights name and save if needed
         if disk_offload_index is not None and len(disk_offload_index) > 0:
Repository: nodejs/node
Pull request: test: avoid `apply()` calls with large amount of elements

These tests are segfaulting in `ulimit -s 512` environment.

Changed files:
filename: test/parallel/test-buffer-includes.js
patch: @@ -213,10 +213,7 @@ assert(!asciiString.includes('\x2061'));
 assert(asciiString.includes('leb', 0));
 
 // Search in string containing many non-ASCII chars.
-const allCodePoints = [];
-for (let i = 0; i < 65534; i++) allCodePoints[i] = i;
-const allCharsString = String.fromCharCode.apply(String, allCodePoints) +
-    String.fromCharCode(65534, 65535);
+const allCharsString = Array.from({ length: 65536 }, (_, i) => String.fromCharCode(i)).join('');
 const allCharsBufferUtf8 = Buffer.from(allCharsString);
 const allCharsBufferUcs2 = Buffer.from(allCharsString, 'ucs2');
 

filename: test/parallel/test-buffer-indexof.js
patch: @@ -285,10 +285,7 @@ assert.strictEqual(-1, asciiString.indexOf('\x2061'));
 assert.strictEqual(asciiString.indexOf('leb', 0), 3);
 
 // Search in string containing many non-ASCII chars.
-const allCodePoints = [];
-for (let i = 0; i < 65534; i++) allCodePoints[i] = i;
-const allCharsString = String.fromCharCode.apply(String, allCodePoints) +
-    String.fromCharCode(65534, 65535);
+const allCharsString = Array.from({ length: 65536 }, (_, i) => String.fromCharCode(i)).join('');
 const allCharsBufferUtf8 = Buffer.from(allCharsString);
 const allCharsBufferUcs2 = Buffer.from(allCharsString, 'ucs2');
Repository: denoland/deno
Pull request: fix(ext/node): worker_threads copies env object

Most common argument to `env` option for `worker_threads.Worker` will be `process.env`.
In Deno `process.env` is a `Proxy` which can't be cloned using structured clone algorithm.
So to be safe, I'm creating a copy of actual object before it's sent to the worker thread.

Ref #23522

Changed files:
filename: ext/node/polyfills/worker_threads.ts
patch: @@ -29,7 +29,7 @@ import { EventEmitter } from "node:events";
 import { BroadcastChannel } from "ext:deno_broadcast_channel/01_broadcast_channel.js";
 import process from "node:process";
 
-const { ObjectPrototypeIsPrototypeOf } = primordials;
+const { JSONParse, JSONStringify, ObjectPrototypeIsPrototypeOf } = primordials;
 const {
   Error,
   Symbol,
@@ -126,10 +126,18 @@ class NodeWorker extends EventEmitter {
     }
     this.#name = name;
 
+    // One of the most common usages will be to pass `process.env` here,
+    // but because `process.env` is a Proxy in Deno, we need to get a plain
+    // object out of it - otherwise we'll run in `DataCloneError`s.
+    // See https://github.com/denoland/deno/issues/23522.
+    let env_ = undefined;
+    if (options?.env) {
+      env_ = JSONParse(JSONStringify(options?.env));
+    }
     const serializedWorkerMetadata = serializeJsMessageData({
       workerData: options?.workerData,
       environmentData: environmentData,
-      env: options?.env,
+      env: env_,
     }, options?.transferList ?? []);
     const id = op_create_worker(
       {

filename: tests/unit_node/worker_threads_test.ts
patch: @@ -10,6 +10,7 @@ import {
 import { fromFileUrl, relative, SEPARATOR } from "@std/path/mod.ts";
 import * as workerThreads from "node:worker_threads";
 import { EventEmitter, once } from "node:events";
+import process from "node:process";
 
 Deno.test("[node/worker_threads] BroadcastChannel is exported", () => {
   assertEquals<unknown>(workerThreads.BroadcastChannel, BroadcastChannel);
@@ -486,3 +487,31 @@ Deno.test({
     await worker.terminate();
   },
 });
+
+Deno.test({
+  name: "[node/worker_threads] Worker env using process.env",
+  async fn() {
+    const deferred = Promise.withResolvers<void>();
+    const worker = new workerThreads.Worker(
+      `
+      import { parentPort } from "node:worker_threads";
+      import process from "node:process";
+      parentPort.postMessage("ok");
+      `,
+      {
+        eval: true,
+        // Make sure this doesn't throw `DataCloneError`.
+        // See https://github.com/denoland/deno/issues/23522.
+        env: process.env,
+      },
+    );
+
+    worker.on("message", (data) => {
+      assertEquals(data, "ok");
+      deferred.resolve();
+    });
+
+    await deferred.promise;
+    await worker.terminate();
+  },
+});
Repository: facebook/react
Pull request: Support `@latest` in prepare-release-from-ci 

Since we track these versions in source, we can build `@latest` releases in CI and store them as artifacts.

Then when it's time to release, and the build has been verified, we use `prepare-release-from-ci` (the same script we use for `@next` and `@experimental`) to fetch the already built and versioned packages.

Changed files:
filename: scripts/release/prepare-release-from-ci.js
patch: @@ -23,7 +23,8 @@ const run = async () => {
       await testPackagingFixture(params);
     }
 
-    await printPrereleaseSummary(params, false);
+    const isLatestRelease = params.releaseChannel === 'latest';
+    await printPrereleaseSummary(params, isLatestRelease);
   } catch (error) {
     handleError(error);
   }

filename: scripts/release/shared-commands/download-build-artifacts.js
patch: @@ -39,10 +39,13 @@ const run = async ({build, cwd, releaseChannel}) => {
     await exec(`rm -rf ./build/node_modules`, {cwd});
   }
   let sourceDir;
+  // TODO: Rename release channel to `next`
   if (releaseChannel === 'stable') {
     sourceDir = 'oss-stable';
   } else if (releaseChannel === 'experimental') {
     sourceDir = 'oss-experimental';
+  } else if (releaseChannel === 'latest') {
+    sourceDir = 'oss-stable-semver';
   } else {
     console.error('Internal error: Invalid release channel: ' + releaseChannel);
     process.exit(releaseChannel);

filename: scripts/release/shared-commands/parse-params.js
patch: @@ -32,17 +32,21 @@ const paramDefinitions = [
     name: 'releaseChannel',
     alias: 'r',
     type: String,
-    description: 'Release channel (stable or experimental)',
+    description: 'Release channel (stable, experimental, or latest)',
   },
 ];
 
 module.exports = async () => {
   const params = commandLineArgs(paramDefinitions);
 
   const channel = params.releaseChannel;
-  if (channel !== 'experimental' && channel !== 'stable') {
+  if (
+    channel !== 'experimental' &&
+    channel !== 'stable' &&
+    channel !== 'latest'
+  ) {
     console.error(
-      theme.error`Invalid release channel (-r) "${channel}". Must be "stable" or "experimental".`
+      theme.error`Invalid release channel (-r) "${channel}". Must be "stable", "experimental", or "latest".`
     );
     process.exit(1);
   }
Repository: huggingface/transformers
Pull request: Cleanup the regex used for doc preprocessing

We had an overly-complex regex designed to capture docstrings, and as a result it has potentially exponential runtime for malicious inputs. This PR makes the following simplifying changes:

- Explicit calls to `re.compile` without saving the compiled object are removed - these only hurt performance (see [note](https://docs.python.org/3/library/re.html#re.compile))
- `re.MULTILINE` was removed because this only [affects the behaviour](https://docs.python.org/3/library/re.html#re.MULTILINE) of `^` and `$` characters, which are not used in this regex
- Over-complex non-capturing group replaced with much simpler regex, because `re.DOTALL` allows `.*?` to go through newlines

cc @Michellehbn!

Changed files:
filename: src/transformers/testing_utils.py
patch: @@ -2732,8 +2732,8 @@ def preprocess_string(string, skip_cuda_tests):
     cuda stuff is detective (with a heuristic), this method will return an empty string so no doctest will be run for
     `string`.
     """
-    codeblock_pattern = r"(```(?:python|py)\s*\n\s*>>> )((?:.*?\n)*?.*?```)"
-    codeblocks = re.split(re.compile(codeblock_pattern, flags=re.MULTILINE | re.DOTALL), string)
+    codeblock_pattern = r"(```(?:python|py)\s*\n\s*>>> )(.*?```)"
+    codeblocks = re.split(codeblock_pattern, string, flags=re.DOTALL)
     is_cuda_found = False
     for i, codeblock in enumerate(codeblocks):
         if "load_dataset(" in codeblock and "# doctest: +IGNORE_RESULT" not in codeblock:
Repository: huggingface/transformers
Pull request: Make the flaky list a little more general

cc @gante, I also saw `HfHubHTTPError` in flaky tests, so I rewrote the list to include that too!

Changed files:
filename: .circleci/create_circleci_config.py
patch: @@ -41,8 +41,7 @@
     "ConnectionError",  # Connection transient error
     "FileNotFoundError",  # Raised by `datasets` on Hub failures
     "PIL.UnidentifiedImageError",  # Raised by `PIL.Image.open` on connection issues
-    "HTTPError.*502",  # Hub-related
-    "HTTPError.*504",  # Hub-related
+    "HTTPError",  # Also catches HfHubHTTPError
     "AssertionError: Tensor-likes are not close!",  # `torch.testing.assert_close`, we might have unlucky random values
     # TODO: error downloading tokenizer's `merged.txt` from hub can cause all the exceptions below. Throw and handle
     # them under a single message.

filename: tests/test_image_processing_common.py
patch: @@ -29,6 +29,7 @@
 from transformers.image_utils import AnnotationFormat, AnnotionFormat
 from transformers.testing_utils import (
     check_json_file_has_correct_format,
+    is_flaky,
     require_torch,
     require_torch_gpu,
     require_vision,
@@ -212,6 +213,7 @@ def test_slow_fast_equivalence_batched(self):
 
     @require_vision
     @require_torch
+    @is_flaky()
     def test_fast_is_faster_than_slow(self):
         if not self.test_slow_image_processor or not self.test_fast_image_processor:
             self.skipTest(reason="Skipping speed test")
Repository: vercel/next.js
Pull request: fix(CI build_and_deploy): Use a larger fetch-depth for build-native job

If not supplied, this defaults to a fetch-depth of 1, which likely explains some of the tagless version strings I've seen...

Use a fetch-depth of 100 so that we're always likely to find a previous tag.

Closes PACK-4193

Changed files:
filename: .github/workflows/build_and_deploy.yml
patch: @@ -297,6 +297,10 @@ jobs:
       # we use checkout here instead of the build cache since
       # it can fail to restore in different OS'
       - uses: actions/checkout@v4
+        with:
+          # crates/napi/build.rs uses git-describe to find the most recent git tag. It's okay if
+          # this fails, but fetch with enough depth that we're likely to find a recent tag.
+          fetch-depth: 100
 
       - name: Setup node
         uses: actions/setup-node@v4
@@ -347,7 +351,17 @@ jobs:
 
       - name: Build in docker
         if: ${{ matrix.settings.docker && steps.build-exists.outputs.BUILD_EXISTS == 'no' }}
-        run: docker run -v "/var/run/docker.sock":"/var/run/docker.sock" -e RUST_BACKTRACE -e NAPI_CLI_VERSION -e CARGO_TERM_COLOR -e CARGO_INCREMENTAL -e CARGO_PROFILE_RELEASE_LTO -e CARGO_REGISTRIES_CRATES_IO_PROTOCOL -e TURBO_API -e TURBO_TEAM -e TURBO_TOKEN -e TURBO_VERSION -e TURBO_CACHE="remote:rw" -v ${{ env.HOME }}/.cargo/git:/root/.cargo/git -v ${{ env.HOME }}/.cargo/registry:/root/.cargo/registry -v ${{ github.workspace }}:/build -w /build --entrypoint=bash ${{ matrix.settings.docker }} -c "${{ matrix.settings.build }}"
+        run: |
+          docker run -v "/var/run/docker.sock":"/var/run/docker.sock" \
+            -e CI -e RUST_BACKTRACE -e NAPI_CLI_VERSION -e CARGO_TERM_COLOR -e CARGO_INCREMENTAL \
+            -e CARGO_PROFILE_RELEASE_LTO -e CARGO_REGISTRIES_CRATES_IO_PROTOCOL -e TURBO_API \
+            -e TURBO_TEAM -e TURBO_TOKEN -e TURBO_VERSION -e TURBO_CACHE="remote:rw" \
+            -v ${{ env.HOME }}/.cargo/git:/root/.cargo/git \
+            -v ${{ env.HOME }}/.cargo/registry:/root/.cargo/registry \
+            -v ${{ github.workspace }}:/build \
+            -w /build \
+            --entrypoint=bash ${{ matrix.settings.docker }} \
+            -c "${{ matrix.settings.build }}"
 
       - name: cache build
         if: ${{ matrix.settings.docker && steps.build-exists.outputs.BUILD_EXISTS == 'no' }}
Repository: facebook/react
Pull request: Use ReactVersions module as package allowlist

Instead of keeping a separate allowlist in sync, we use ReactVersions.js as the source of truth for which packages get published.

Changed files:
filename: ReactVersions.js
patch: @@ -50,7 +50,6 @@ const experimentalPackages = [
   'react-fs',
   'react-pg',
   'react-server-dom-webpack',
-  'react-server',
 ];
 
 // TODO: Export a map of every package and its version.

filename: scripts/release/utils.js
patch: @@ -11,6 +11,7 @@ const {join} = require('path');
 const createLogger = require('progress-estimator');
 const prompt = require('prompt-promise');
 const theme = require('./theme');
+const {stablePackages, experimentalPackages} = require('../../ReactVersions');
 
 // https://www.npmjs.com/package/progress-estimator#configuration
 const logger = createLogger({
@@ -132,42 +133,11 @@ const getCommitFromCurrentBuild = async () => {
 };
 
 const getPublicPackages = isExperimental => {
-  // TODO: Use ReactVersions.js as source of truth.
+  const packageNames = Object.keys(stablePackages);
   if (isExperimental) {
-    return [
-      'create-subscription',
-      'eslint-plugin-react-hooks',
-      'jest-react',
-      'react',
-      'react-art',
-      'react-dom',
-      'react-is',
-      'react-reconciler',
-      'react-refresh',
-      'react-test-renderer',
-      'use-subscription',
-      'scheduler',
-      'react-fetch',
-      'react-fs',
-      'react-pg',
-      'react-server-dom-webpack',
-    ];
-  } else {
-    return [
-      'create-subscription',
-      'eslint-plugin-react-hooks',
-      'jest-react',
-      'react',
-      'react-art',
-      'react-dom',
-      'react-is',
-      'react-reconciler',
-      'react-refresh',
-      'react-test-renderer',
-      'use-subscription',
-      'scheduler',
-    ];
+    packageNames.push(...experimentalPackages);
   }
+  return packageNames;
 };
 
 const handleError = error => {
Repository: nodejs/node
Pull request: test: increase test coverage for `http.OutgoingMessage.appendHeader()`


Changed files:
filename: test/parallel/test-http-multiple-headers.js
patch: @@ -64,6 +64,10 @@ const server = createServer(
       res.write('BODY');
       res.end();
 
+      assert.throws(() => res.appendHeader(), {
+        code: 'ERR_HTTP_HEADERS_SENT',
+      });
+
       assert.deepStrictEqual(res.getHeader('X-Res-a'), ['AAA', 'BBB', 'CCC']);
       assert.deepStrictEqual(res.getHeader('x-res-a'), ['AAA', 'BBB', 'CCC']);
       assert.deepStrictEqual(
Repository: vercel/next.js
Pull request: Alternate bundler: show state in app info message

When next starts, in either `next dev` or `next start`, we log a message
that includes Turbopack state (`▲ Next.js 15.3.0-canary.12
(Turbopack)`). This implements it for rspack as well.

Test Plan:

Configure the rspack plugin and start `next dev`. Confirm `▲ Next.js
15.3.0-canary.12 (rspack)` is shown.

Run `next dev --turbopack`. Verify Turbopack is shown instead.


Closes PACK-4195

Changed files:
filename: packages/next/src/server/lib/app-info-log.ts
patch: @@ -23,10 +23,19 @@ export function logStartInfo({
   experimentalFeatures?: ConfiguredExperimentalFeature[]
   maxExperimentalFeatures?: number
 }) {
+  let bundlerSuffix
+  if (process.env.TURBOPACK) {
+    bundlerSuffix = ' (Turbopack)'
+  } else if (process.env.NEXT_RSPACK) {
+    bundlerSuffix = ' (Rspack)'
+  } else {
+    bundlerSuffix = ''
+  }
+
   Log.bootstrap(
     `${bold(
       purple(`${Log.prefixes.ready} Next.js ${process.env.__NEXT_VERSION}`)
-    )}${process.env.TURBOPACK ? ' (Turbopack)' : ''}`
+    )}${bundlerSuffix}`
   )
   if (appUrl) {
     Log.bootstrap(`- Local:        ${appUrl}`)